Re: Preventing private procedure visibility being made public through extension

["Randy Brukardt" <randy@rrsoftware.com>]

Ah, a subtype. GNAT has (or had?)a bug having to do with making things 
visible because of a subtype declaration (I recall someone else running 
across that and having verified it myself). That's just plain wrong, a 
subtype has no effect on what's visible in a prefixed call (or anywhere else 
for that matter, in particular with "use all type").

You ought to have an ambiguity if you tried to call Something in the body of 
More_Derived, but it should be OK in the main subprogram.

I'd skip the subtype and just use the real name of the type. And possibly 
make a bug report to AdaCore.
You could also use a traditional call (More_Derived.Something (M, P);) which 
would avoid the buggy part of GNAT.

                                        Randy.

"Jere" <jhb.chat@gmail.com> wrote in message 
news:62e326e6-dd15-4546-83dc-b1e423327c23@googlegroups.com...
> On Thursday, May 25, 2017 at 3:40:01 PM UTC-4, Randy Brukardt wrote:
>> Your probably having trouble with the appropriaate view of My_Type. The 
>> full
>> type of My_Type has both versions of Create (of course), as it inherits 
>> from
>> View_Type. If you try to extend somewhere where that full view is 
>> visible,
>> then that extension too will get both Creates. (That includes in the body
>> and in any child packages.)
>>
>> OTOH, an extension somewhere that only has visibility on the private 
>> type,
>> you should only get one (visible) Create. (But the other one is still
>> inherited, it just can't be called directly.)
>>
>> I could go into more detail if you need that; it would help to have a 
>> full
>> compilable example in that case so I can see where everything is 
>> declared.
>>
>>                            Randy.
>>
>>
>
> This might be a better example.  I have 3 tiers: 
> Base/Derived/More_Derived
>
> More_Derived publicly inherits off of Base but privately inherits off of
> Derived.
>
> Derived provides a Something procedure and More_Derived provides a 
> Something
> procedure but uses a different signature and is not overriding (I double
> checked by putting "overriding" with it and noted the compiler error).
>
> More_Derived does not have private view of Derived, but GNAT still says
> there is a ambiguity.  I don't see how More_Derived has a private
> view of Derived, so I think this is a bug, but I might be missing
> something.
>
> main.adb
> *******************************************
> with Base;
> with Derived;
> with More_Derived;
>
> procedure Main is
>   p : Base.Derived_Param;
>
>   subtype My_Type is More_Derived.More_Derived_Type;
>
>   m : My_Type;
> begin
>   m.Something(p);  -- ERROR:  ambiguous call to Something
> end Main;
> *******************************************
>
>
> base.ads
> *************************************************
> package Base is
>
>   type Base_Param is tagged null record;
>   type Derived_Param is new Base.Base_Param with null record;
>
>   type Base_Type is tagged null record;
>
> end Base;
> *************************************************
>
>
> derived.ads
> *************************************************
> with Base;
>
> package Derived is
>
>   type Derived_Type is new Base.Base_Type with null record;
>
>   procedure Something
>      (Obj   : in out Derived_Type;
>       Value :        Base.Base_Param'Class)
>   is null;
>
> end Derived;
> *************************************************
>
>
> more_derived.ads
> *************************************************
> with Base;
> with Derived;
>
> package More_Derived is
>
>   type More_Derived_Type is new Base.Base_Type with private;
>
>   procedure Something
>      (Obj   : in out More_Derived_Type;
>       Value :        Base.Derived_Param'Class)
>   is null;
>
> private
>
>   type More_Derived_Type is new Derived.Derived_Type with null record;
>
> end More_Derived;
> *************************************************
>
> If I don't use the subtype in main.adb, it compiles fine.