Re: Elaboration of nested generic package.

[dlwester@hotmail.com (Don Westermeyer)]

> 
> I don't think it matters much what the generic itself says.  Whenever
> you instantiate a generic package, you should always Elaborate_All on
> the with clause:
> 
> with GP;
> pragma Elaborate_All (GP);  --you need this
> 
> package body Q is
>    package P is new GP;
> end Q;
> 
> See the CLA thread "AQ&S Guidance on pragma Elaborate_Body" which
> occurred in 1997/04 -- particularly the responses from Bob Duff and
> Robert Dewar.
> 
> I forget whether you need the pragma for root-level instantiations:
> 
> with GP;
> pragma Elaborate_All (GP); --needed?
> package P is new GP;
> 
> I don't think the pragma inside the generic declaration does very
> much, except to indicate to the reader about whether the package uses
> named access types, etc.  It's the Elaborate_All pragma that's
> important for generics.
> 
> Perhaps Bob Duff can, er, elaborate.
> 
> -Matt
You should not need an Elaborate_All pragma if the specification
contains pragma Elaborate_Body since the body is elaborated
immediately after the specification.

Using Elaborate_All certainly works also, but a lot of people either
forget or more often just don't bother using it.  It seems to me using
pragmas Pure, Preelaborate, and Elaborate_Body should make usage of a
package more fool-proof.  When used, they also then to enforce that
designers and programmers develop software using non-circular,
'top-down' designs.

It seems to me that the Ada language should have assumed an
'Elaborate_All' for every dependancy unless a pragma was used to
specifically ignore it.  It would seem the compilers should also know
when it can ignore elaboration checking without the user specifying
Pure or Preelaborate.

I'd say most of the people maintaining large Ada projects do not even
know the issues of elaboration and how to deal with them. (And it's
not like there's a lot of money for training these days.)


Usually I do use pragma Elaborate_All for every dependancy anyway
since one does not have control over every software module developed. 
Using it is always safer and causes no penalties that I know of
(assuming the design stays clear of mutual dependancies).