component values into a composite value of an array type, record type,
or record extension.]
Name Resolution Rules
The expected type for an aggregate
shall be a single array type, record type, or record extension.
There are additional rules for each kind of aggregate. These aggregate
rules are additive; a legal expression needs to satisfy all of the applicable
rules. That means the rule given here must be satisfied even when it
is syntactically possible to tell which specific kind of aggregate is
shall not be of a class-wide type.
Ramification: When the expected type
in some context is class-wide, an aggregate has to be explicitly qualified
by the specific type of value to be created, so that the expected type
for the aggregate itself is specific.
We used to disallow aggregate
of a type with unknown discriminants. However, that was unnecessarily
restrictive in the case of an extension aggregate, and irrelevant to
a record aggregate (since a type that is legal for a record aggregate
could not possibly have unknown discriminants) and to an array aggregate
(the only specific types that can have unknown discriminants are private
types, private extensions, and types derived from them).
For the evaluation of an aggregate
an anonymous object is created and values for the components or ancestor
part are obtained (as described in the subsequent subclause for each
kind of the aggregate
and assigned into the corresponding components or ancestor part of the
Obtaining the values and the assignments
occur in an arbitrary order.
The value of the aggregate
is the value of this object.
The ancestor part is the
set of components inherited from the ancestor type. The syntactic category
is the expression
that specifies how the ancestor part of the anonymous object should be
The assignment operations
do the necessary value adjustment, as described in 7.6
Note that the value as a whole is not adjusted — just the subcomponents
(and ancestor part, if any). 7.6
when this anonymous object is finalized.
If the ancestor_part
is a subtype_mark
the Initialize procedure for the ancestor type is applied to the ancestor
part after default-initializing it, unless the procedure is abstract,
as described in 7.6
. The Adjust procedure for
the ancestor type is not called in this case, since there is no assignment
to the ancestor part as a whole.
If an aggregate
is of a tagged type, a check is made that its value belongs to the first
subtype of the type.
Constraint_Error is raised if
this check fails.
This check ensures that
no values of a tagged type are ever outside the first subtype, as required
for inherited dispatching operations to work properly (see 3.4
This check will always succeed if the first subtype is unconstrained.
This check is not extended to untagged types to preserve upward compatibility.
Extensions to Ada 83
Wording Changes from Ada 83
We have adopted new wording for expressing the
rule that the type of an aggregate shall be determinable from the outside,
though using the fact that it is nonlimited record (extension) or array.
now creates an anonymous object. This is necessary so that controlled
types will work (see 7.6
Incompatibilities With Ada 95
In Ada 95, a limited type is not considered when
resolving an aggregate
Since Ada 2005 now allows limited aggregate
we can have incompatibilities. For example:
type Lim is limited
type Not_Lim is
procedure P(X: Lim);
procedure P(X: Not_Lim);
P((Comp => 123)); -- Illegal in Ada 2005, legal in Ada 95
The call to P is ambiguous in Ada 2005, while
it would not be ambiguous in Ada 95 as the aggregate
could not have a limited type. Qualifying the aggregate
will eliminate any ambiguity. This construction would be rather confusing
to a maintenance programmer, so it should be avoided, and thus we expect
it to be rare.
Extensions to Ada 95
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe