Re: Erasing inappropriate operations

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Randy Brukardt writes:
> In Ada 95, abstract operators of untagged types are considered in
> resolution. So, you still might call them;then get an error message. That is
> especially problematical if an appropriate operator is defined somewhere
> else, because the expression might be ambiguous. (It's also a problem with
> literals).
> 
> The Amendment 1 changed that so that they do not participate in resolution.
> Thus, they no longer clog up resolution.
> 
> For instance, if you had:
>
>      type F1 is digits 3;
>      type F2 is digits 3;
>      function "*" (Left : F1, Right : F2) return F2;
>      function "*" (Left, Right : F2) return F2 is abstract; -- Don't want
> this operator.
>
>      A : F1 := 1.0;
>      B : F2 := A * 1.0; -- (1)
>
> The expression (1) is ambiguous in Ada 95 (even though one of the possible
> operators is illegal). But Amendment 1 makes it OK; you'll get the intended
> operator without interference from the predefined ones you don't want.

Even in Ada 95 mode, GNAT does not consider (1) to be ambiguous
because only one of the operators matches the actual parameter
profile.  Is this a bug?

In the absence of the first (non-abstract) operator, it says "cannot
call abstract subprogram".  Fair enough, I still see no bug here.

Or perhaps you meant...

with Ada.Text_IO;
procedure Proc1 is
   type F1 is digits 3;
   type F2 is digits 3;
   function "*" (Left : F1; Right : F2) return F2;
   function "*" (Left, Right : F2) return F2
     is abstract; -- Don't want this operator.

   function "*" (Left : F1; Right : F2) return F2 is
   begin
      Ada.Text_IO.Put_Line ("* called");
      return F2 (Float (Left) * Float (Right));
   end "*";

   A : F1 := 1.0;
   B : F2 := 1.0 * F2 (A); -- (1)
begin
   null;
end Proc1;

which gives me:

gcc-4.1 -c -gnatwa -gnat95 proc1.adb
proc1.adb:15:18: ambiguous expression (cannot resolve "*")
proc1.adb:15:18: possible interpretation at line 6
proc1.adb:15:18: possible interpretation at line 5

The abstract subprogram is indeed considered in overload resolution.
But since the resolution fails (the call is ambiguous), there is still
no way to call the abstract subprogram.  So if I understand correctly,
in Amendment 1, the call is no longer ambiguous and the first operator
is called.  Correct?

-- 
Ludovic Brenta.