Re: Ada202X: Easy to use "UML private"-like components

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

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:

> Pkg.T corresponds to a Modula-2 opaque type (or opaque eport, if you
> prefer). Both the Ada compiler and the Modula-2 compiler know, based on
> the package declaration or the definition module, that Pkg.T is a
> pointer. Neither compiler knows anything about the type of the object to
> which Pkg.T points, until the package body or implementation module is
> compiled.

The compilation model is that when compiling something, the compiler
looks at information coming from the specs of imported things, but not
their bodies.  Modula-2 compilers actually work that way, and this
is the reason for the must-be-pointer (or must be the same size as
a pointer, or smaller, as I had (mis?)remembered it).

It is also the reason for the private part kludge: the compiler sees
the size of the full type for a private type (assuming it is known
at compile time).  But this reasoning makes no sense to me, because
that's not how Ada compilers work.  Any reasonable implementation
of generics and inlining needs to look at bodies.  So full types
should be in bodies, and compilers should look there (at least
in optimizing mode) to find out their size.

On the other hand, the private part kludge wouldn't be so bad if
the syntax were different:  The private part should be a separate
syntactic compilation_unit, with its own with clauses, and should
normally be stored in a separate source file from the visible part.
There's an awful lot of horrible code duplication caused by the
fact that the private part is in the same file as the visible part.
Separating it out into a different file would not prevent the
compiler from looking at it!

- Bob