Re: Equivalent of dynamic_cast (downcast) for tagged types

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

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:joz7ejpgeda0$.etbrqjysvoke$.dlg@40tude.net...
> On Fri, 28 Jan 2011 05:11:16 -0800 (PST), AdaMagica wrote:
>
>> On 28 Jan., 10:16, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
>> wrote:
>>> On Thu, 27 Jan 2011 14:35:28 -0800 (PST), Maciej Sobczak wrote:
>>>> I have submitted this bug report more than one year ago. Looks like
>>>> nobody even bothered to check it.
>>>
>>> Well, I am not a language lawyer to tell if the behavior (public 
>>> overriding
>>> of a private primitive operation) is legal.
>>>
>>>> The bug submission states that Adjust is wrongly recognized as
>>>> overriding, which it shouldn't be - but now I have hit something more
>>>> interesting.
>>>
>>> It must be overriding because Adjust is a primitive operation. Whether 
>>> the
>>> compiler should allow it to become publicly declared as an overriding is
>>> another question.
>>
>> The public specification of Ada.Finalization.Limited_Controlled has no
>> Adjust operation, so there is no primitive operation with that name
>> which you can override, full stop.
>
> It has no *visible* primitive operation.
>
>> It's irrelevant if there is some
>> internal one deeply burrowed in the compiler's implementation.
>
> Unfortunately it leaks out. Consider this:
>
> package P is
>   type T is tagged private;
> private
>   type T is tagged null record;
>   procedure Foo (X : in out T);
> end P;
>
> with P;
> package Q is
>   type S is new P.T with null record;
>   procedure Foo (X : in out S);
> end Q;
>
> with Q;
> package P.R is
>   type U is new Q.S with null record;
>   procedure Bar (Object : in out U'Class);
> end P.R;
>
> package body P.R is
>   procedure Bar (Object : in out U'Class) is
>   begin
>      Foo (Object); -- Which Foo is called here? Is there one or two?
>   end Bar;
> end P.R;
>
> This problem can also be observed with components. E.g. P.T may have a
> component Baz, declared privately. Q.S may have "another" Baz declared
> publicly. P.R.U faces a name conflict which must be resolved in some of 
> two
> possible ways: "overloading" vs. "overriding."

In both of these of these cases, there are two operations (no overriding 
happens). Either one of the Foos is invisible (in which case you get the 
visible one), or the program is illegal because it is ambiguous.

The same happens for the components, with the exception that the type 
extension is illegal if there is anywhere in the program where two 
components with the same name could be visible. (That's necessary because 
they're not overloadable.)

That's what the *language* says; any particular compiler may have bugs in 
this area. For instance, Janus/Ada has an invariant that all component names 
must be unique. That means an attempt to declare an extension like the one 
in this example will always fail, even when the hidden components never 
would be visible. That's wrong, and needs to get fixed someday, but is not 
much of a priority (the bug is pervasive - the invariant simply is wrong, 
but virtually all of the component processing code -- designed for Ada 83 --  
depends on it, so the fix is very expensive,  the bug is rare in real code, 
and often when it happens the type would have been illegal anyway).

                                       Randy.