Re: Type vs subtype about visibility of parent's private full definition

[Simon Wright <simon@pushface.org>]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

> I already encountered something similar in the past, and it's back
> again. I can only solve it using a subtype instead of a type‑new where
> I initially want a type‑new, so I'm not happy with using subtype.
>
> The case: a child package don't see the full definition of a type from
> the private part of its parent package when it derives from that type
> as a type‑new.
>
> Below is an example, using a discriminant, which is not required to
> expose the visibility issue, but which is the reason why I'm not happy
> to not be able to derive a type‑new instead of a subtype: I can't
> force static‑check as I expected. If the discriminant was not part of
> the party, I won't bother. That's the reason why the example makes use
> of a discriminant and I see the case as an issue.
>
>
> Example:
>
>
>     package Parents is
>
>        pragma Pure;
>
>        type Discriminant_Type is
>           range 1 .. 5;
>
>        type Instance_Type
>          (Discriminant : Discriminant_Type) is
>           private;
>
>     private
>
>        type Instance_Type
>          (Discriminant : Discriminant_Type) is
>           record
>              Value : Integer;
>           end record;
>
>     end Parents;
>
>     package Parents.Childs is
>
>        pragma Pure;
>
>        subtype Parent_Type is
>           Parents.Instance_Type;
>
>        type Instance_Type is
>           new Parent_Type
>             (Discriminant => 2);

There may or may not be a compiler bug triggered by this form, but I
don't understand why you say "I can only solve it using a subtype
instead of a type‑new where I initially want a type‑new, so I'm not
happy with using subtype" because if I write instead of Parent_Type and
Instance_Type above

   type Instance_Type is
     new Parents.Instance_Type
     (Discriminant => 2);

or

   subtype Instance_Type is
     Parents.Instance_Type
     (Discriminant => 2);

it compiles OK.

>        function Value
>          (Object : Instance_Type)
>           return Integer;
>
>     private
>
>        function Value
>          (Object : Instance_Type)
>           return Integer
>           is (Object.Value); -- << Error here
>
>     end Parents.Childs;
>
>
> I did not check the RM, however I'm blocked if I do this, as GNAT has
> complaints with `is (Object.Value)`, and grumbles:
>
>
>     no selector "Value" for private type derived from "Instance_Type"
>
>
> I can just work around it, defining `Parents.Childs.Instance_Type`
> this way:
>
>
>        subtype Instance_Type is
>           Parent_Type
>             (Discriminant => 2);
>
>
> … instead of this way (as was in the above package definition):
>
>
>        type Instance_Type is
>           new Parent_Type
>             (Discriminant => 2);
>
>
> I may be naive, I believe `Parents.Childs` private part should see the
> full definition of `Parents.Instance_Type` in both case, not only when
> deriving a subtype.
>
> What are your opinions about this issue?