[ruby-talk:01179] Re: Possible bug in ruby-man-1.4

[e-mail] (Yukihiro Matsumoto) writes:

> |Maybe the answer is to get rid of the concept of negative numeric
> |literals, so there's never any ambiguity as to whether -2 is a literal 
> |of a method call? Then, as an optimization, the parser could notice
> |<Fixnum>.-@ terminal pairs and replace them with a negated
> |Fixnum.
> 
> That is the current behavior (without optimization). 

Is that true, though?  1 + -2 seems to invoke 1.+, passing in negative 
2, without invoking 2.-@. The code in parse.y does:

  | tUMINUS arg
    {
	if ($2 && nd_type($2) == NODE_LIT && FIXNUM_P($2->nd_lit)) {
	    long i = FIX2LONG($2->nd_lit);
	    $2->nd_lit = INT2FIX(-i);
	    $$ = $2;
	}
	else {
	    $$ = call_op($2, tUMINUS, 0, 0);
        }

So 'tUMINUS Fixnum' will always be reduced to a negative Fixnum. I was 
suggesting that optimization could be deferred until the tree is
built, and you know that the Fixnum is a terminal. That way, you'd
convert the '2' in '1 + -2', but not the '2' in -2.abs.


> The problem is about the contradiction below.
>                                                    current modified
>   -13.remainder(4) => better be (-13).remainder(4)   yes      no
>   -2**2            => better be -(2**2)              no       yes
> 
> There may be good syntax rules to solve this.

Should "-2 op 2" always evaluate to the same as "-2.op(2)"? If not,
then what's the effect of bumping the precedence of method application 
down below unary minus? (This strikes me as a frightening change ;-)

Dave