Can we fix reverse operator overloading (opSub_r et. al.)?

[Lars T. Kyllingstad]

Don wrote:
> Currently, template versions of opXXX_r appear to be useless.
> Consider:
> 
> struct A
> {
>    int opSub(T)(T x) { return 1; }
>    int opSub_r(T)(T x) { return -1; }
> }
> 
> A a;
> int x = a - a; // is this a.opSub(a) or a.opSub_r(a) ???
> 
> This is annoying and rather silly. I can't imagine a case where you 
> would template opXXX_r, without also templating opXXX. And by 
> definition, a.opSub(a) is identical to a.opSub_r(a). Templated opSub_r 
> has a broken design in both D1 and D2.
> 
> We could fix it by adding a rule to operator overloading:
> 
> [New rule] 1. If a and b have the same type, the expression is written 
> as a.opfunc(b).
> [Existing rules] 2. If any a.opfunc or b.opfunc_r functions exist, then 
> overloading is applied across all of them and the best match is used.
> ...
> 
> Patching this is pretty easy. For example, in DMD2.031, opover.c, line 
> 263, simply add:
> 
>      if ((t1 == t2)) {
>         //  x OP x can only be x.opOP(x), not x.opOP_r(x)
>         s_r = NULL;
>     }


I recently ran into the exact same issue, so I agree completely.

-Lars