Re: Elaboration order handling (Was: Bug in 'gnatmake')

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org> writes:

> Since we're discussing elaboration order, there's a case that I wonder about:

A case of mutually-recursive packages.  That's unusual, because it's
usually better to design software in layers, where higher layers
use the lower layers, but not vice-versa.

But sometimes such mutually-dependent packages are exactly the
right thing.

> with B;
>
> package A is
>    function F (I : Integer) return B.Thing;
>
>    function R return Integer;
> end A;
>
> package body A is
>    function F (I : Integer) return B.Thing is
>       -- null;
>    begin -- F
>       return B.To_Thing (I);
>    end F;
>
>    function R return Integer is
>       -- null;
>    begin -- R
>       return 7;
>    end R;
> end A;
>
> package B is
>    type Thing is private;
>
>    function To_Thing (I : Integer) return Thing;
> private -- B
>    type Thing is new Integer;
> end B;
>
> with A;
>
> package body B is
>    function To_Thing (I : Integer) return Thing is
>       -- null;
>    begin -- To_Thing
>       return Thing (I);
>    end To_Thing;
>
>    C : constant Integer := A.R;
> end B;

In standard Ada, the above is perfectly legal, and does not
raise Program_Error.

> It seems to me there's a valid elaboration order for these:
>
> * spec of B
> * spec of A
> * body of A
> * body of B

Yes, and that is the only order allowed by the RM.

> I've never been able to get such code to bind, though. Is there some way
> to get this accepted, or is it illegal Ada?

Without -gnatE, GNAT will complain about an elaboration cycle,
because it is inserting an implicit "pragma Elaborate_All(A);"
on the body of B.  It does that because it's trying to preserve
abstraction -- it wants the code to work no matter what
A.R does (it's not looking at the body of A.R while compiling
body of B).  In fact, A.R could have called A.F, in which case
the program is broken -- the only allowed order causes Program_Error
in standard Ada, and the whole point of the not-gnatE mode is
to do all such run-time checks statically.
Imagine adding that call to A.F during maintenance.

And the reason the implicit pragma causes a cycle is that 
Elaborate_All is transitive -- it requires the body of
B to be elaborated before the body of B, which is impossible.

But you've got mutual recursion here, so A and B are necessarily
tightly coupled, and you, the programmer, can know that A.R does
NOT call anything in B.  In that case, you can solve the problem
by putting "pragma Elaborate(A);" on the body of B.  GNAT uses
that Elaborate *instead* of the implicit Elaborate_All, and Elaborate
is nontransitive, so it all works, using the order you showed above.

But be careful:  If you later change A.R to call A.F, you'll be
in trouble.

The other way to get this example to work is to use -gnatE.
I don't recommend that.

- Bob

P.S. I don't like your convention of putting "-- null;" in empty
declarative parts!  Comments should impart useful information,
and empty declarative parts are nothing special, and anyway,
I can see it's empty without a comment.