Re: making a son benefit access ton an instanciation of a generic package required as a formal parameter to his father and instanciated by him

["Randy Brukardt" <randy@rrsoftware.com>]

"Simon Wright" <simon@pushface.org> wrote in message 
news:ly8tcp28nv.fsf@pushface.org...
> "J-P. Rosen" <rosen@adalog.fr> writes:
>
>> Right, and there is a good reason.
>> Assuming exception E is declared in generic package GP1:
>>
>> Imagine this:
>> generic
>>    package P1 is new GP1 (<>);
>>    package P2 is new GP1 (<>);
>> package GP2 is... end GP2;
>>
>> package body GP2 is
>>    ...
>> begin
>>    exception
>>       when P1.E =>  -- not allowed by Ada
>>          ...
>>       when P2.E =>  -- not allowed by Ada
>>          ...
>> end GP2;
>>
>> So far, so good. But then, if you instantiate:
>> package Inst1 is new GP1;
>>
>> package Inst2 is new GP2 (Inst1, Inst1);
>>
>> then you would end up with two different handlers for the same
>> exception (since formals P1 and P2 are actually the same package
>> Inst1). And
>
> This doesn't seem a million miles away from having name clashes caused
> by use-visibility.
>
> Agreed, the _instantiation_ must fail.

Ah, but remember the "language-lawyer" message I wrote a few minutes ago. 
Ada enforces Legality Rules in the body in an "assume-the-worst" manner. 
Thus, if any possible instantiation would cause a failure, it is illegal in 
a generic body.

This was done to make the contract model of generics sensible. If one can 
compile a generic body, then the body is always legal for an instantation. 
This allows sane separate compilation, where the body doesn't necessarily 
exist when the instantation is compiled. If the instantiation proves legal 
when compiled, it will stay that way regardless of what is in the body. 
Otherwise, you would have the legality of instantiations changing when a 
body is changed, meaning that you would be getting errors in far off 
compilation units.

Some compilers do in fact do pure macro substitutions, and give the effect 
of proper separate compilation by compiling the instances during binding. 
This is OK and not noticable to a user, because those instances have to be 
legal (modulo compiler bugs, of course). If a compiler worked this way 
without the assume-the-worst rules, you'd get lots of error messages at bind 
time, long after you thought you had a clean compile. That would be annoying 
at best.

                                      Randy.