Version 1.1 of ai05s/ai05-0118-1.txt

Unformatted version of ai05s/ai05-0118-1.txt version 1.1
Other versions for file ai05s/ai05-0118-1.txt

!standard 6.4(9)          08-10-16 AI05-0118-1/01
!standard 6.4.1(2)
!standard 12.3(9)
!class binding interpretation 08-10-16
!status work item 08-10-16
!status received 08-08-06
!priority Low
!difficulty Easy
!qualifier Omission
!subject How do parameter associations associate?
!summary
Positional associations associate to formals in the order that they are given in the call or instance.
!question
It appears that the Standard does not contain any definition of how positional notation is interpreted in the cases of subprogram calls and generic instantiations.
This is defined in 3.7.1(5) for discriminant constraints, and in 4.3.1(11) and 4.3.3(1) for aggregates. But there does not seem to be any corresponding language in 6.4 or 6.4.1 for subprograms, nor in 12.3 for generic instantiations.
!recommendation
(See Summary.)
!wording
Add after 6.4(9):
A positional parameter_association corresponds to the formal parameter with the same position in the formal part.
AARM To Be Honest: This is after any transformation of prefixed views.
[Editor's Note: Is this good enough, or do we want to try to take prefixed views into account here? Note that we didn't change the wording of the rest of this for prefixed views.]
Modify 6.4.1(2):
The formal_parameter_selector_name of a parameter_association shall resolve to denote a parameter_specification of the view being called{; the parameter_association is associated with the denoted formal parameter}.
[One could argue that this entire rule belongs in 6.4, as it is needed to understand/enforce 6.4(9). But as Name Resolution Rules are all combined anyway, and moving it seems like too much change for a very minor fix.]
Add after 12.3(9):
A positional generic_association corresponds to the generic_formal_parameter_declaration with the same position in the generic_formal_part.
[Editor's note: Have to put this here so that it can be used in the following legality rule. We could add it to the start of 12.3(10) instead.]
!discussion
Wording defining the associations was present in the Ada 83 Standard, in 6.4(3): "For a positional association, the actual parameter corresponds to the formal parameter with the same position in the formal part."
This wording was present in early versions of the Ada 9x standard, but it disappears in version 3.0. Since it wasn't moved anywhere, was just lost.
It should be noted that there is no clear specification of the association for named parameter associations either; 6.4.1(2) only mentions the resolution of the parameter name, and does not clearly state that the association associated with the denoted formal parameter. We add a few words to make that clear (it would odd without them, given the wording for positional notation).
It might be thought that the wording for subprogram positional calls needs to take into account calls of prefixed views:
A.Op (B);
In this call, B associated with the second formal parameter. However, we lean on on the equivalence defined in 6.4(10.1/2) and don't change the wording.
--!corrigendum 13.11(16)
!ACATS Test
This has been tested in the ACATS since the dawn of (Ada) time.
!appendix

!topic "Positional notation" not defined
!reference 6.4, 12.3
!from Adam Beneschan 08-08-06
!discussion

This is probably a very minor point.  But it appears to me that the RM does not
contain any definition of how positional notation is interpreted in the cases
of subprogram calls and generic instantiations. 

For discriminant constraints, 3.7.1(5) does define this ("the associated
discriminant is the one whose discriminant_specificaxtion occurred in the
corresponding position...").  Similarly for record aggregates, in 4.3.1(11).

But I can't find any similar language for subprogram calls.  The Ada
83 manual did mention this (RM83 6.4(3): "For a positional association,
the actual parameter corresponds to the formal parameter with the same position
in the formal part").  This language seems to have gotten lost when things got
rearranged for Ada 95.  I can't find anything like it in 6.4, 6.4.1, or anywhere else.

Similarly, I can't find any similar language about positional associations for
actual parameters in generic instantiations.  (The Ada 83 manual handled this
by saying "in the same manner as parameter associations of subprogram calls".)

This may not be a serious problem---everyone seems to know how it works.
It conceivably *could* be a problem for an Ada newcomer who is used to languages
without default parameters; if a subprogram is defined like

    procedure P (A : Type_1 := Some_Default_Expression;
                 B : Type_2);

and the newcomer wants to know if, in a call to P(X), the X is the actual
parameter for "A" or if "A" is skipped because it has a default expression, he's
not going to find the answer in the RM because it isn't there.  That's just
hypothetical, of course.

****************************************************************


Questions? Ask the ACAA Technical Agent