4.3 Aggregates
1
[
{aggregate}
An
aggregate combines component values into
a composite value of an array type, record type, or record extension.]
{literal: See also aggregate}
Syntax
2
aggregate ::= record_aggregate |
extension_aggregate |
array_aggregate
Name Resolution Rules
3/2
{
AI95-00287-01}
{expected type (aggregate) [partial]}
The expected type for an
aggregate
shall be a single
nonlimited array type,
record type, or record extension.
3.a
Legality Rules
4
An aggregate shall not
be of a class-wide type.
4.a
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.
4.b
Discussion: We used to disallow aggregates
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).
Dynamic Semantics
5
{evaluation (aggregate)
[partial]} 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 anonymous object.
{assignment
operation (during evaluation of an aggregate)} Obtaining
the values and the assignments occur in an arbitrary order. The value
of the
aggregate is the value of this object.
5.a
Discussion: The ancestor part is the
set of components inherited from the ancestor type. The syntactic category
ancestor_part is the expression
or subtype_mark that specifies how the ancestor
part of the anonymous object should be initialized.
5.b
Ramification: 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 also describes
when this anonymous object is finalized.
5.c
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.
6
{Discriminant_Check
[partial]} {check,
language-defined (Discriminant_Check)} 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
(raised by failure of run-time check)} Constraint_Error
is raised if this check fails.
6.a
Ramification: 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
6.b
{
extensions to Ada 83}
We
now allow
extension_aggregates.
Wording Changes from Ada 83
6.c
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.
6.d
An
aggregate now
creates an anonymous object. This is necessary so that controlled types
will work (see
7.6).
Incompatibilities With Ada 95
6.e/2
{
AI95-00287-01}
{incompatibilities with Ada 95} In
Ada 95, a limited type is not considered when resolving an aggregate.
Since Ada 2005 now allows limited aggregates,
we can have incompatibilities. For example: 6.f/2
type Lim is limited
record
Comp: Integer;
end record;
6.g/2
type Not_Lim is
record
Comp: Integer;
end record;
6.h/2
procedure P(X: Lim);
procedure P(X: Not_Lim);
6.i/2
P((Comp => 123)); -- Illegal in Ada 2005, legal in Ada 95
6.j/2
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
6.k/2
{
AI95-00287-01}
{extensions to Ada 95} Aggregates
can be of a limited type.
Sponsored by Ada-Europe