Re: Possible Ada deficiency?

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

Nick Roberts <nick.roberts@acm.org> writes:

> I've heard the same, and I think it might be correct. There's no real
> technical barrier to types being completed in the body, other than it might
> cause some compilers to have to (effectly) make an extra pass. (Correct?)

I'm not sure what you mean by "extra pass".  The issue is whether the
compiler looks at the body while compiling clients.

The main thing is that the compiler needs to know the size of a private
type in order to allocate things, unless it treats all private types as
dynamic-sized, which would be annoying -- you shouldn't have to pay an
efficiency cost to get the benefits of encapsulation, information
hiding, etc.  So if the full type were in the body, the compiler would
have to look at the body (at least in optimizing mode).

And if the compiler looks at the body, then you have to recompile all
the clients when the body changes (unless you're doing fancy incremental
compilation -- that's the kind of compiler I'd really like to have!).

Another point is that the rules about whether to pass by copy or by
reference depend on the full type.  I don't much like that, but anyway,
the compiler would have to look at the body to find out, unless the
decision is made at run time, which would be grossly inefficient.

So I guess the Ada 83 designers invented the private part so the
compiler wouldn't have to look at the body to generate efficient code.
But the compiler has to look at the body anyway, in order to implement
generics (unless they are always code-shared) and pragmas Inline.
So the decision seems somewhat inconsistent to me.

If JDI had not invented private parts, so we just had spec and body, and
all the hidden stuff goes in the body, then when Tucker came along and
invented child packages, he would have given them visibility into the
body.  And we'd be having this same discussion about how do you prevent
evil children from seeing what they shouldn't.  I still think the right
answer is to restrict which children are allowed, rather than to have
yet another special visibility rule.

By the way, is the original poster worried that subunits can see all
kinds of hidden stuff in the parent body?  That case seems less
worrisome, because the parent mentions the names of all subunits.
The language could allow the same thing for children (but it shouldn't
*require* it).

- Bob