Re: Ada Annoyances

[Robert A Duff <bobduff@TheWorld.com>]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> "Robert A Duff" <bobduff@TheWorld.com> wrote in message 
> news:wcca84q5vq1.fsf@TheWorld.com...
>> Niklas Holsti <niklas.holsti@tidorum.invalid> writes:
> ...
>> I agree, I don't see a problem here.  When Finalize is called, it
>> dispatches via the currrent Tag.  Tags can't change in Ada, but if they
>> could it would still dispatch via the Tag value present when Finalize is
>> called.
>
> That's not the problem. The problem is knowing whether to call Finalize at 
> all. The only solution I could see for the GNAT approach is to treat all 
> tagged objects as controlled (using a null Finalize in cause the object 
> isn't controlled). That's expensive.

In this fictional/future version of Ada, I presume the Tag of an object
could only change if it's a class-wide object.  So you don't have to
finalize all tagged objects -- just class-wide ones, and that's
essentially what GNAT is doing anyway.  E.g. if you say:

    X : T'Class := F(...);

the compiler doesn't know whether X contains controlled subcomponents,
so it does a dispatching call to a compiler-generated primitive of T,
which finalizes components, or does nothing.

GNAT can optimize that away if you use the No_Finalization restriction.
Maybe also the Disable_Controlled aspect on a type -- not sure about
that.

> For a list-based approach (like the one Janus/Ada uses), I don't see any 
> solution at all. Putting every tagged object on the finalization lists would 
> be prohibitively expensive.

Again, not every tagged object, just every class-wide object.

Actually, not even that.  Just every class-wide object that
uses this new feature.  It would be known at the root of
the type hierarchy whether Tags can change.  So there's no
distributed overhead.

- Bob