Operator Overloading Resolution

Operator Overloading Resolution

[rds]

The following code segment was compiled using Telesoft 3.15.
According to LRM 6.6(3) "A call to an overloaded subprogram is
ambiguous (and therefore illegal) if...<the parameters>...are
not sufficient to determine exactly one (overloaded) subprogram
specification."

LRM 4.6(15) also states that a conversion can be applied
"if and only if the innermost complete context (see 8.7)
determines a unique (numeric) target type for the implicit
conversion." 


 WORD	: constant := 16;
 
 type INT_SCALAR is range -(2**15) .. (2**15)-1;
 for INT_SCALAR'size use WORD;
  
 left	: INTEGER range -127..128;
 result	: BOOLEAN;
 
 function "-"( right  : in INT_SCALAR) return INT_SCALAR is
     begin
 	return INT_SCALAR(-INTEGER( right ));
     end;
 
 begin
    result := left < -15;
                   -
>>>    Incompatible operand types or operator not visible <4.5 8.3 8.7>

--------------------------------------------------------------------
The expression -15 is evaluated to be of type INT_SCALAR.

Shouldn't this be an ERROR?

DECAda compiles this code without warning, implying the expression -15
is an INTEGER type.

My impression is NEITHER compiler follows the LRM.
Any comments on what is correct, or what other compilers do?

Richard DeSimine        (201) 386-2059
AT&T Bell Laboratories, Whippany, New Jersey 07054

Re: Operator Overloading Resolution

[wayne]

> /* Written  1:59 pm  Aug  4, 1988 by rds@moss.ATT.COM in inmet:comp.lang.ada */
> /* ---------- "Operator Overloading Resolution" ---------- */
> The following code segment was compiled using Telesoft 3.15.
 
  ...
> The expression -15 is evaluated to be of type INT_SCALAR.

> Shouldn't this be an ERROR?

No. DEC-Ada is correct, Telesoft is in error.  The expression "15"
is of course of type UNIVERSAL_INTEGER.  According to LRM 4.10 and 
LRM 4.16:15 the subexpression "-15" is therefore also of universal
integer, regardless of a function definition.  It is then implicitly
converted to INTEGER (LRM 4.6:15) when evaluating the rest of the
expression because "left" is defined to be of INTEGER and a "<" is
available with two INTEGER parameters which returns BOOLEAN.

It can be assumed that if it possible for a subexpression to be of
type universal expression, it will be of type universal expression.
If you wish to use your definition of the negation operator, you
must qualifiy the 15 to be of type INT_SCALAR , such as in

     result := left < - INT_SCALAR'(15);

then it will be ambiguous, because there is no "<" defined to take
both an INTEGER and an INT_SCALAR.  Don't forget to initialize 
"left" or you may get an exception at run_time.     

Wayne Wylupski
Intermetrics, Inc.
Cambridge, MA

Re: Operator Overloading Resolution

[Matti J{rvinen]

In article <30740@clyde.ATT.COM> rds@clyde.ATT.COM (Richard DeSimine) writes:
>    result := left < -15;
>--------------------------------------------------------------------
>The expression -15 is evaluated to be of type INT_SCALAR.
>
>Shouldn't this be an ERROR?

Yes, it is.

>DECAda compiles this code without warning, implying the expression -15
>is an INTEGER type.

No, it does NOT imply expression -15 to be integer. The expression is of
type universal_integer, which DECAda correctly transforms to the same type than
variable left.



-- 
Hannu-Matti Jarvinen, Tampere University of Technology, Finland
hmj@tut.fi, hmj@tut.uucp, hmj@tut.funet (tut.ARPA is not the same computer).

Re: Operator Overloading Resolution

[rds]

Hannu-Matti Jarvinen writes:

>>    result := left < -15;
>>--------------------------------------------------------------------
>>The expression -15 is evaluated to be of type INT_SCALAR.
>>
>>Shouldn't this be an ERROR?
>
>Yes, it is.
>
>>DECAda compiles this code without warning, implying the expression -15
>>is an INTEGER type.
>
>No, it does NOT imply expression -15 to be integer. The expression is of
>type universal_integer, which DECAda correctly transforms to the same type than
>variable left.
>
, Tampere University of Technology, Finland
>hmj@tut.fi, hmj@tut.uucp, hmj@tut.funet (tut.ARPA is not the same computer).

INTEGER or universal_integer, it it still ambiguous and in its context
could be construed as an INT_SCALAR or a universal_integer and is,
according to the LRM, illegal. Looking back at the original example,
where the unary operator "-" is overloaded, this would imply that
there is a precedence associated with a predefined and overloaded 
operators. If this is legal, then predefined operators have precedence
over programmer defined operators.

Consider the case where the variable "left" is of type INT_SCALAR and
not of type INTEGER. A compiler should evaluate the expression -15
before resolving the arguments passed to the relational operator "<".

The question really is: should the compiler evaluate the "-" operator
as the predefined unary "-" or the overloaded unary "-".  I say the
expression is ambiguous, and should be an error.

Richard DeSimine (201) 386-2059
AT&T Bell Laboratories, Whippany, New Jersey 07981