3.11.1 Completions of Declarations
Throughout the RM95, there are rules about completions that define
Which declarations require a corresponding
Which constructs can only serve as the completion
of a declaration.
Where the completion of a declaration is allowed
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.
An incomplete type (whether declared in the limited view of a package
or not) may be completed by a private type declaration, so we can in
fact have four
In Ada 2012, there are no language-defined pragmas that act as completions.
Pragma Import (which is obsolescent) has the effect of setting aspect
Import to True; such an aspect makes giving a completion illegal. The
wording that allows pragmas as completions was left as it is harmless
and appears in many places in this Reference Manual.
Name Resolution Rules
A construct that can
be a completion is interpreted as the completion of a prior declaration
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
An implicit declaration shall not have a completion.
any explicit declaration that is specified to require completion
there shall be a corresponding explicit completion, unless the declared
entity is imported (see B.1
To be honest:
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
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
and not entities (subprograms). When a completion is required, it has
to be explicit; the implicit null package_body
that Clause 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
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.
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
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.
Completions are in principle allowed for any kind of explicit declaration.
However, for some kinds of declaration, the only allowed completion is
an implementation-defined pragma, and implementations are not required
to have any such pragmas.
99 There are rules that prevent premature
uses of declarations that have a corresponding completion. The Elaboration_Checks
prevent such uses at run time for
subprograms, protected operations, tasks, and generic units. The 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
Wording Changes from Ada 2005
Added null procedures and expression functions that are completions to
the definition of body
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe