Building limited types through nested creator functions

[Simon Belmont <sbelmont700@gmail.com>]

Hi,

Consider two limited record types, inner and outer, with the former
nested inside the latter.  If the records are public, then code can
initialize the outer by specifying an aggregate for the inner, as in:

type Inner is limited
  record
    e : Integer;
  end record;

type Outer is limited
  record
    i : Inner;
  end record;

o : Outer := Outer'(i => Inner'(e => 42));

However, if types are made private, suitable functions must be
provided to make the appropriate objects.  If just Inner is private,
then this can be done (assuming simple creator functions that just
create the objects with the given values):

o : Outer := Outer'(i => Make_Inner(arg => 42));

but if both are private, then the following:

o : Outer := Make_Outer (arg => Make_Inner(arg => 42));

ends up being illegal, because in the code:

function Make_Outer (arg : Inner) return Outer is
begin
  return Outer'(i => arg);
end Make_Outer

would end up trying to copy a limited type.  For the cases in which an
existing object is passed in, this would be the appropriate action,
but for cases where the object is built-in-place into the argument,
clearly the intended behavior is to build it in place to the resultant
object.  It's easy enough to use an access value, but as unnecessary
use of access values is generally discouraged, I was just curious if
there was an alternative mechanism to achieve the desired effect.

-sb