Version 1.2 of ais/ai-00150.txt

Unformatted version of ais/ai-00150.txt version 1.2
Other versions for file ais/ai-00150.txt

!standard 08.03 (26)          98-06-12 AI95-00150/04
!class binding interpretation 96-09-04
!status WG9 approved 98-06-12
!status ARG Approved 10-0-1 98-04-01
!status ARG Approved (with changes) 13-0-0 97-11-16
!status work item 96-09-06
!status received 96-09-04
!reference AI95-00044
!priority Medium
!difficulty Medium
!subject Uniqueness of Component Names
!summary 98-03-27
For a type extension declared in a child package, where the parent type is declared in an ancestor package, it is illegal for the two types to have duplicate component names.
!question 96-09-08
Consider the following example, inspired by ACVC test C730003:
package Parent is type T is tagged ...; type DT is new T with private; private type DT is new T with record
Y: ...; end record; end Parent;
package Parent.Child is type DDT is new DT with record Y: ...; -- Legal? (No.) end record; end Parent.Child;
Both DT and DDT contain components called Y. Is this name duplication legal? (No.)
!recommendation 96-09-08
(See summary.)
!wording 96-09-08
!discussion 98-03-27
3.4(14) says:
Declarations of components, protected subprograms, and entries, whether implicit or explicit, occur immediately within the declarative region of the type, in the order indicated above, following the parent subtype_indication.
8.3(26) says:
An explicit declaration is illegal if there is a homograph occurring immediately within the same declarative region that is visible at the place of the declaration, and is not hidden from all visibility by the explicit declaration.
It appears that this rule does not apply to the second declaration of Y, above, because the inherited Y is not visible at this place. However, the inherited Y later does become visible, since DDT is in a child package. This is intended to be illegal -- components are not intended to be overridable; nor are they allowed to be overloadable.
The problem is that 8.3(26) and other parts of 8.3 are based on whether certain declarations are implicit or explicit. This leads to the problem addressed by this AI. See also AI95-44, which addresses other problems with the same underlying cause.
The intent is that two or more homographs are not allowed immediately within the same declarative region, if there is a place where both are visible, unless all but one are overridden. (Note however, that this rule does not apply in instances!)
Note that if DDT were declared in another root library unit, rather than in a child of Parent, then the two Y's would be legal, since there would be no place where both are visible.

!section 8.3(26)
!subject 3.9.1(9) & 8.3 don't preclude non-unique component names
!reference RM95-8.3(26), RM95-3.9.1(9)
!keywords homograph
!from Dan Lehman
!reference 96-5601.a Dan Lehman 96-6-14>>

   ACVC 2.0 (& 2.0.1) test C730003 shows an unintended consequence of
changes to the wording of 8.3(26) which contradicts note 3.9.1(9)'s
assertion that "each visible component of a record extension has to have
a unique name."  C730003 declares a private extension in a parent package
from which a child package declares a type extension in the visible part;
at this point, there is no rule forbidding the naming of a new component
with the same name of a component of the parent type declared in the private
part of the parent package--for that characteristic of the parent type
is not visible until the (implicit) private part of the child package.
But 8.3(26) only makes a homograph declaration illegal if "there is a
homograph occurring immediately within the same declarative region THAT
C730003.  An attempt to refer to either homograph is illegal by 8.3(24);
but 8.3(26) should probably be strengthened to make the declaration illegal.

   Below is discussion of this issue regarding a petition against the
validation test.

---Dan Lehman
-------------- *

----- Begin Included Message -----

From: Thu Jun 13 17:56:23 1996
[Dan writes:]
> The following is from an e-mail message from Tucker Taft:
> > I agree this is illegal.  However, I did have some trouble finding the
> > exact wording.  The intent is clear from RM95-3.9.1(9), but you need
> > to combine RM95-3.4(12,14), 7.1(6), 7.3(15), 7.3.1(4), and 8.3(26)
> > to cover this particular case.  The derived type Graphic_Card has an
> > inherited component named "View" implicitly declared at the point where
> > C730003_0.C730003_1 gains visibility on the private part of its parent
> > unit, which occurs at the beginning of its own (implicit) private part.
> > At this point, it violates 8.3(26), making the compilation illegal.
> Here is a compiler listing for the test:
>   167   View : Graphic_Representation;   -- (B)
>         ^^^^                             -- "Duplicate" component field name
>   >>>> Error:  Illegal to override declaration in same region, LRM:8.3(26)
> -----------------------------------------------------------------------------
>    I concur in the sentiment that 3.9.1(9) shows that the code above is
> wrong, but I disagree with the petitioner/implementation & Tuck about
> exactly why it's wrong.  Tuck's msg. admits that he had trouble finding
> "the exact wording" to support the petition; I submit that he in fact
> didn't find it, but came close enough for others to find it.  In short,
> 8.3(26) doesn't cover the case at hand because it applies only where the
> implicit declaration "is visible AT THE PLACE OF the (explicit) declaration,
> which is not the case in C730003 and which is the point of the test; but
> 8.3(24) seems to apply to later code where the selector_name "View" must
> be resolved but is ambiguous (for the derived type).
>    Tuck's citations lead one to conclude that, at some point after the last
> declaration in the visible part of the child package, the inherited implicit
> declaration of component View from the parent becomes visible.  But this is
> too late for 8.3(26)'s restriction to apply and make the declaration of a
> homograph @167 illegal.  So, there must at this point, immediately before
> the end of the package declaration, be two Views (that one can't use)--I
> don't see any rule to forbid this.

I guess I agree.  I was concluding that the declaration of the inherited
component was illegal by 8.3(26), but I now see that 8.3(26) only applies
to explicit declarations.  It turns out we had more correct, but arguably
more obscure, wording in an earlier version of Ada 9X (version 4.0),
in paragraph 8.3(24):

    A compilation unit is illegal if it contains a place where two explicit
    homographs that occur immediately with the same declarative region are
    simultaneously visible. ...

Unfortunately, this suffers from the requirement that both be "explicit."
As we have noted elsewhere, the whole distinction between explicit and
implicit declarations is bogus, and creates all kinds of bizarre notions
like explicit implicit declarations inside generic instances, etc..

The key distinction is between "inherited primitives", and all others.
Inherited primitives may be overridden.  Nothing else may be overridden,
independent of whether it is explicit or implicit.

The correct rule is:
   It is illegal to have two simultaneously visible homographs declared
   immediately in the same declarative regions, unless one or both
   are inherited primitives.

> ...
> Should there be an AI to make the above case indeed an illegality of 8.3(26),
> to manifest the hope of note #69 (3.9.1:9) there?

Yes, we should have an AI that rewrites all of this garbage about
implicit vs. explicit in terms of inherited primitives vs. others.

> ---Dan


----- End Included Message -----


Questions? Ask the ACAA Technical Agent