Parameter Associations
Author: JTC1/SC22/WG9/ARG, by Randall Brukardt, ARG Editor

Ada Reference Manual — Legal Information

# 6.4.1 Parameter Associations

1
A parameter association defines the association between an actual parameter and a formal parameter.

#### Name Resolution Rules

2/3
The formal_parameter_ selector_name of a named parameter_association shall resolve to denote a parameter_specification of the view being called; this is the formal parameter of the association. The formal parameter for a positional parameter_association is the parameter with the corresponding position in the formal part of the view being called.
3
The actual parameter is either the explicit_actual_parameter given in a parameter_association for a given formal parameter, or the corresponding default_expression if no parameter_association is given for the formal parameter. The expected type for an actual parameter is the type of the corresponding formal parameter.
4
If the mode is in, the actual is interpreted as an expression; otherwise, the actual is interpreted only as a name, if possible.

#### Legality Rules

5
If the mode is in out or out, the actual shall be a name that denotes a variable.
6/3
If the formal parameter is an explicitly aliased parameter, the type of the actual parameter shall be tagged or the actual parameter shall be an aliased view of an object. Further, if the formal parameter subtype F is untagged:
6.1/3
the subtype F shall statically match the nominal subtype of the actual object; or
6.2/3
the subtype F shall be unconstrained, discriminated in its full view, and unconstrained in any partial view.
6.3/3
In a function call, the accessibility level of the actual object for each explicitly aliased parameter shall not be statically deeper than the accessibility level of the master of the call (see 3.10.2).
6.4/3
Two names are known to denote the same object if:
6.5/3
both names statically denote the same stand-alone object or parameter; or
6.6/3
both names are selected_components, their prefixes are known to denote the same object, and their selector_names denote the same component; or
6.7/3
both names are dereferences (implicit or explicit) and the dereferenced names are known to denote the same object; or
6.8/3
both names are indexed_components, their prefixes are known to denote the same object, and each of the pairs of corresponding index values are either both static expressions with the same static value or both names that are known to denote the same object; or
6.9/3
both names are slices, their prefixes are known to denote the same object, and the two slices have statically matching index constraints; or
6.10/3
one of the two names statically denotes a renaming declaration whose renamed object_ name is known to denote the same object as the other, the prefix of any dereference within the renamed object_ name is not a variable, and any expression within the renamed object_ name contains no references to variables nor calls on nonstatic functions.
6.11/3
Two names are known to refer to the same object if
6.12/3
The two names are known to denote the same object; or
6.13/3
One of the names is a selected_component, indexed_component, or slice and its prefix is known to refer to the same object as the other name; or
6.14/3
One of the two names statically denotes a renaming declaration whose renamed object_ name is known to refer to the same object as the other name.
6.15/3
If a call C has two or more parameters of mode in out or out that are of an elementary type, then the call is legal only if:
6.16/3
For each name N that is passed as a parameter of mode in out or out to the call C, there is no other name among the other parameters of mode in out or out to C that is known to denote the same object.
6.17/3
If a construct C has two or more direct constituents that are names or expressions whose evaluation may occur in an arbitrary order, at least one of which contains a function call with an in out or out parameter, then the construct is legal only if:
6.18/3
For each name N that is passed as a parameter of mode in out or out to some inner function call C2 (not including the construct C itself), there is no other name anywhere within a direct constituent of the construct C other than the one containing C2, that is known to refer to the same object.
6.19/3
For the purposes of checking this rule:
6.20/3
For an array aggregate, an expression associated with a discrete_choice_list that has two or more discrete choices, or that has a nonstatic range, is considered as two or more separate occurrences of the expression;
6.21/3
For a record aggregate:
6.22/3
The expression of a record_component_association is considered to occur once for each associated component; and
6.23/3
The default_expression for each record_component_association with <> for which the associated component has a default_expression is considered part of the aggregate;
6.24/3
For a call, any default_expression evaluated as part of the call is considered part of the call.

#### Dynamic Semantics

7
For the evaluation of a parameter_association:
8
The actual parameter is first evaluated.
9
For an access parameter, the access_definition is elaborated, which creates the anonymous access type.
10
For a parameter (of any mode) that is passed by reference (see 6.2), a view conversion of the actual parameter to the nominal subtype of the formal parameter is evaluated, and the formal parameter denotes that conversion.
11
For an in or in out parameter that is passed by copy (see 6.2), the formal parameter object is created, and the value of the actual parameter is converted to the nominal subtype of the formal parameter and assigned to the formal.
12
For an out parameter that is passed by copy, the formal parameter object is created, and:
13/3
For an access type, the formal parameter is initialized from the value of the actual, without checking that the value satisfies any constraint, any predicate, or any exclusion of the null value;
13.1/3
For a scalar type that has the Default_Value aspect specified, the formal parameter is initialized from the value of the actual, without checking that the value satisfies any constraint or any predicate;
14
For a composite type with discriminants or that has implicit initial values for any subcomponents (see 3.3.1), the behavior is as for an in out parameter passed by copy.
15
For any other type, the formal parameter is uninitialized. If composite, a view conversion of the actual parameter to the nominal subtype of the formal is evaluated (which might raise Constraint_Error), and the actual subtype of the formal is that of the view conversion. If elementary, the actual subtype of the formal is given by its nominal subtype.
15.1/3
In a function call, for each explicitly aliased parameter, a check is made that the accessibility level of the master of the actual object is not deeper than that of the master of the call (see 3.10.2).
16
A formal parameter of mode in out or out with discriminants is constrained if either its nominal subtype or the actual parameter is constrained.
17
After normal completion and leaving of a subprogram, for each in out or out parameter that is passed by copy, the value of the formal parameter is converted to the subtype of the variable given as the actual parameter and assigned to it. These conversions and assignments occur in an arbitrary order.

#### Erroneous Execution

18/3
If the nominal subtype of a formal parameter with discriminants is constrained or indefinite, and the parameter is passed by reference, then the execution of the call is erroneous if the value of any discriminant of the actual is changed while the formal parameter exists (that is, before leaving the corresponding callable construct).

Ada 2005 and 2012 Editions sponsored in part by Ada-Europe