Re: Package's private parts and protected types

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

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message 
news:wccr5orgwhd.fsf@shell01.TheWorld.com...
> "Randy Brukardt" <randy@rrsoftware.com> writes:
>
>>...(For Janus/Ada, at least, every source file is compiled
>> separately, and code is generated as necessary without needing anything
>> other than direct semantic dependencies to have been previously compiled.
>> That model is impossible for separate private parts; the specification 
>> would
>> not contain enough information to generate any code or any code for calls 
>> to
>> it.)
>
> The Ada 83 model seemed to be that the compiler doesn't need to look at
> with'ed bodies to generate code.  But that's bogus.

It's not bogus, the existence of Janus/Ada demonstrates that. And other Ada 
83 compilers worked that way as well.

> All Ada compilers
> other than Janus/Ada look at bodies to generate code for generic
> instantiations.  And you need to look at bodies to implement
> inlining properly.  (Does Janus/Ada implement inlining?)
> Similarly for any other inter-package optimizations.

I don't believe in inlining(*). Nor inter-package optimizations in typical 
compilation modes. Our model is that the only dependencies are the actual 
semantic dependencies caused by with clauses (and stubs, which work much 
like with clauses). Everything was designed to have tolerable compilation 
speeds on original PCs, and no program library at all (just a pile of files 
somewhere). Obviously, those choices aren't as important these days, I 
wouldn't design it the same if I was starting today.

(*) I think inlining is something that should be done automatically by the 
compiler. I see no reason at all to clutter source code with hints that the 
compiler could figure out better on its own. It would be much better if the 
source was annotated with the intended time/space tradeoffs: make this loop 
as fast as possible, make this rarely used subsystem as small as possible, 
make everything else "normal". This is one advantage that just-in-time 
compilation has: it actually has data to suggest what is important.

I also believe that the only reasonable compilation model in the limit is of 
full program compilation - if I started a compiler design today I would 
build it around that model where most of the work is done at what today is 
called "link-time". (Or even just-in-time.) So if we're talking hypothetical 
languages, compilation would also be very different. But this is an Ada 
forum, and I'm not much interested in hypotheticals.

                                      Randy.