Re: Type in allocator has deeper level than designated class-wide type

[Adam Beneschan <adam@irvine.com>]

On Jun 13, 6:07 pm, Adrian Hoe <aby...@gmail.com> wrote:

> I changed the line in procedure Add from
>
>       New_Element := new Element_Record'
>                         ( Constructor.Init ( Name, Color, Data) ) ;
>
> to
>
>       New_Element := new Element_Record;
>
> The compiler is still pointing the same warning to this line.
>
> What exactly does the warning message "Type in allocator has deeper
> level than designated class-wide type" mean? Is the compiler unable to
> determine the size of the array during allocation? Or the array is a
> level deeper than the List.Access_Node?

It has nothing to do with arrays.  When you declare a type as "access
all T'Class", an object of that type can't be made to point to a type
declared in a more deeply nested subprogram.  A simple example:

package Pack1 is
    type Root is tagged null record;
    type Acc is access all Root'Class;
end Pack1;

package Pack2 is
    procedure Proc1;
end Pack2;

with Pack1;
package body Pack2 is
    procedure Proc1 is
        type Child is new Pack1.Root with null record;
        A : Pack1.Acc;
    begin
        A := new Child;   -- ILLEGAL
    end Proc1;
end Pack2;

This assignment statement is illegal, because somewhere later, A could
be copied to, say, another variable of type Pack1.Acc declared
globally in the body of Pack2, and then you'd have a pointer to a
Child that would exist after Proc1 has exited and the Child type no
longer exists, which is a big no-no.  4.8(5.1) prohibits this.

Since in this case, the record type (Element_Record) is declared in a
generic, that complicates things, because the generic *could* be
instantiated inside a procedure, which would lead to the same sort of
problem as above.  I don't remember all the rules, but depending on
where the type is declared and where the allocator occurs (generic
specification or body), it might be illegal to instantiate this
generic inside a procedure, or it might cause Program_Error to be
raised.  I just tried our compiler again and modified the source to
instantiate High_Cloud; if there's an instance of High_Cloud inside a
procedure, it *does* give a warning that Program_Error will be raised
(if the "new Element_Record" expression is reached).  If your compiler
gives the warning when the generic is first seen, before an instance
of the generic is seen, that's just a choice your compiler makes.  But
unless your program is arranged in a different order than I'm
guessing, or unless there are some new Ada 2012 rules that I'm not yet
familiar with, the compiler should not reject your generic, and it
should not reject it or cause Program_Error to be raised if there's an
instance of the generic that is *not* inside a subprogram.

                                  -- Adam