3.11.1 Completions of Declarations
{
8652/0014}
{
AI95-00064-01}
Declarations sometimes come in two parts.
{requires
a completion} A declaration that requires
a second part is said to
require completion.
{completion
(compile-time concept)} The second part
is called the
completion of the declaration (and of the entity
declared), and is either another declaration, a body, or a
pragma.
A
{body} body
is a
body,
an
entry_body,
or a renaming-as-body (see
8.5.4).
Discussion:
Throughout the RM95, there are rules about completions that define
the following:
Which declarations require a corresponding
completion.
Which constructs can only serve as the completion
of a declaration.
Where the completion of a declaration is allowed
to be.
What kinds of completions are allowed to correspond
to each kind of declaration that allows one.
Don't confuse this compile-time concept with
the run-time concept of completion defined in
7.6.1.
Note that the declaration of a private type
(if limited) can be completed with the declaration of a task type, which
is then completed with a body. Thus, a declaration can actually come
in three parts.
{
AI95-00217-06}
In Ada 2005 the limited view of the package contains an incomplete view
of the private type, so we can have
four parts now.
Name Resolution Rules
A construct that can
be a completion is interpreted as the completion of a prior declaration
only if:
The declaration and the completion occur immediately
within the same declarative region;
If the declaration is overloadable, then the completion
either has a type-conformant profile, or is a
pragma.
{type conformance (required)}
Legality Rules
An implicit declaration shall not have a completion.
{requires a completion [distributed]}
For any explicit declaration that is specified to
require completion, there shall be a corresponding explicit completion.
To be honest: {
AI95-00217-06}
The implicit declarations occurring in a limited view do have a completion
(the explicit declaration occurring in the full view) but that's a special
case, since the implicit declarations are actually built from the explicit
ones. So they do not
require a completion, they have one by
fiat.
Discussion: The implicit declarations
of predefined operators are not allowed to have a completion. Enumeration
literals, although they are subprograms, are not allowed to have a corresponding
subprogram_body.
That's because the completion rules are described in terms of constructs
(
subprogram_declarations)
and not entities (subprograms). When a completion is required, it has
to be explicit; the implicit null
package_body
that Section 7 talks about cannot serve as the completion of a
package_declaration
if a completion is required.
At most one completion is allowed for a given declaration.
Additional requirements on completions appear where each kind of completion
is defined.
Ramification: A subunit is not a completion;
the stub is.
If the completion of a declaration is also a
declaration, then that declaration might have a completion, too.
For example, a limited private type can be completed with a task type,
which can then be completed with a task body. This is not a violation
of the “at most one completion” rule.
{completely defined}
A type is
completely defined at a place that
is after its full type definition (if it has one) and after all of its
subcomponent types are completely defined. A type shall be completely
defined before it is frozen (see
13.14 and
7.3).
Reason: Index types are always completely
defined — no need to mention them. There is no way for a completely
defined type to depend on the value of a (still) deferred constant.
91 Completions are in principle allowed
for any kind of explicit declaration. However, for some kinds of declaration,
the only allowed completion is a
pragma
Import, and implementations are not required to support
pragma
Import for every kind of entity.
Discussion: In fact, we expect that implementations
will
not support pragma Import of things like types — it's
hard to even define the semantics of what it would mean. Therefore, in
practice,
not every explicit declaration can have a completion.
In any case, if an implementation chooses to support pragma Import for,
say, types, it can place whatever restrictions on the feature it wants
to. For example, it might want the
pragma
to be a freezing point for the type.
92 There are rules that prevent premature
uses of declarations that have a corresponding completion. The Elaboration_Checks
of
3.11 prevent such uses at run time for
subprograms, protected operations, tasks, and generic units. The rules
of
13.14, “
Freezing
Rules” prevent, at compile time, premature uses of other entities
such as private types and deferred constants.
Wording Changes from Ada 83
This subclause is new. It is intended to cover
all kinds of completions of declarations, be they a body for a spec,
a full type for an incomplete or private type, a full constant declaration
for a deferred constant declaration, or a
pragma
Import for any kind of entity.
Wording Changes from Ada 95
Sponsored by Ada-Europe