Re: Conversion of Access Types Question

["Paul S. Heidmann" <psh@neta.com>]

David C. Hoos, Sr. wrote:
> 
> Paul S. Heidmann wrote in message <369DFFFC.A160D47C@neta.com>...
> >Greetings fellow Ada lovers!
> >
> >I'm an experienced Ada83 programmer that is learning to use Ada95.
> >Things are going very well, but I don't understand the problems
> >that I'm having converting access types that point to variables of
> >class wide types.  Consider the following piece of code:
> >
> >=======================================
> >
> >procedure Types is
> >
> >   type T1 is tagged
> >      record
> >         I : Integer;
> >      end record;
> >   type A_T1 is access all T1'Class;
> >
> >   type T2 is new T1 with
> >      record
> >         I2 : Integer;
> >      end record;
> >   type A_T2_Classwide is access all T2'Class;
> >   type A_T2 is access T2;
> >
> >   Thing1 : A_T1;
> >   Thing2 : A_T2_Classwide;
> >   Thing3 : A_T2;
> >
> >begin
> >   Thing1 := new T2;
> >   Thing2 := A_T2_Classwide (Thing1);
> >   Thing3 := A_T2 (Thing1);  -- illegal, types are not convertable.
> >end Types;
> >
> >=======================================
> >
> >My question is, why is the last line an illegal conversion, but the
> >second to last line not?
> >
> Compiling your code with gnat results in the following message:
> 
>   [hoosd@VISNT021 d:/gnat_examples]$ gcc -c types.adb
>   types.adb:23:14: target type must be general access type
>   types.adb:23:14: add "all" to type "A_T2" defined at line 14
> 
> Making the change the compiler directs solves the problem.
> 
> i.e., change line 14 to read:
>    type A_T2 is access all T2;

I already understood that could solve the problem by making A_T2
a generalized access type (that's why I have type A_T2_Classwide,
above).  I question is why is this the case?  I could have been
clearer...  Let me give it another try.

A_T2_Classwide is an access type to a group of types rooted at
T2.  In my understanding, the 'class, when applied to T2, refers
to a set of types rooted at T2.  T1, in the above code, would not be
in T2'class, right?  T2 would be in T1'class, however.  Therefore,
A_T1 could point to an object of type T1 or of type T2 (and can, see
first line of code).  If Thing1, above, points to an object of type
T2 (and it does), then I should be able to covert it to A_T2 (but I
can't).  Why is it that adding a 'class, which only refers to things
derived from T2, makes the conversion from A_T1 (which has nothing to
do with T2'Class) legal?

Thanks!

Paul Heidmann