Re: Will "renames" increase program size?

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Wed, 15 Jun 2011 23:59:35 -0700 (PDT), AdaMagica wrote:

> On 15 Jun., 15:15, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>> On Wed, 15 Jun 2011 13:24:52 +0200, Yannick Duchêne (Hibou57) wrote:
>>> Le Wed, 15 Jun 2011 07:37:22 +0200, Randy Brukardt <ra...@rrsoftware.com>  
>>> a écrit:
>>>> Some examples where there probably would be some overhead:
>>
>>>>              Obj : Natural renames My_Array (Some_Variable).all;
>>>>              Obj2 : Float renames Some_Function (A, B);
>>
>>> Yes, because this is more an aliasing (in the symbolic sense) than a  
>>> proper renaming.
>>
>> Yes, Ada's renaming is not renaming. Consider this:
>>
>>    Line : String renames Get_Line;
>>
>> It calls Get_Line once and keeps the result object. In fact it is an
>> equivalent to:
>>
>>    <anonymous> : constant String := Get_Line;
>>    Line : properly renames <anonymous>;
>>
>> Consider also the effect of renaming on the visibility rules:
>>
>>    package P1 is
>>       End_Error : exception renames Ada.Text_IO.End_Error;
>>    end P1;
>>    package P2 is
>>       End_Error : exception renames Ada.Text_IO.End_Error;
>>    end P2;
>>    use P1, P2;
>>
>>    exception
>>       when End_Error => -- End_Error is hidden!
>>
>> Ada's "renames" does not rename here, it copies, creates objects. There are
>> three End_Error here, all of them are equal, but not same:
>>
>> exception
>>    when Ada.Text_IO.End_Error =>
>>       ...
>>    when P1.End_Error => -- Error! P1.End_Error has the same value
>>       ...
>>    when P2.End_Error =>
>>       ...
>>
>> A proper renaming would create identical (x≡y) entities, Ada's renaming
>> sometimes creates only equal ones (x=y).
>>
>> --
>> Regards,
>> Dmitry A. Kazakovhttp://www.dmitry-kazakov.de
> 
> That's not correct. A renaming does not copy nor somehow create new
> entities, it only creates new names for the same thing. Since
> visibility is via names, you arrive at unresolvability issues.

No. First, sometimes it certainly copies, e.g. when the function's result
is renamed, the result (temporary object) is copied. The compiler might
optimize the temporary object away, or even mandated to do so for limited
results, but *semantically* it is a copy.

Compare it with array indexing, which is a properly renamed result, as a
lazy expression or using aliasing.

The wisdom of allowing renaming function results is questionable, but if
allowed it should be lazy. Laziness could also solve this disgrace of Ada's
renaming:

with Ada.Text_IO;  use Ada.Text_IO;

procedure Shame is
   type T is array (Integer range <>) of Integer;
   A : T := (0 => 0, 1 => 1);
   subtype S is T (1..2);
   B : S renames A;
begin
   Put_Line (Integer'Image (B (0))); -- Surprise, 0 is a legal index of S!
end Shame;

Regarding the visibility rules, the design bug is that the new name of a
thing shall not hide any other names of it in any context. In the example
above P1.End_Error should not have hidden P2.End_Error. (I don't know why
this has not been fixed long time ago, because it would be a really minor
language change, which would not break any existing code).

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de