Re: namespaces -- time to do something?

[Olivier Galibert <Olivier.Galibert@mines.u-nancy.fr>]

On Tue, Dec 09, 1997 at 06:44:01PM -0800, Jason Merrill wrote:
> I've already sent out my design for a rewrite of the lookup code, which is
> already ill-suited to C++.  I'll see about digging it up again.

Per Jason's request, here comes his post again.

  OG.

To: egcs@cygnus.com
From: Jason Merrill <jason@yorick.cygnus.com>
Newsgroups: cygnus.egcs
Subject: Re: Test run and a question

>>>>> "Lassi A Tuura" <Lassi.Tuura@cern.ch> writes:

> Mike Stump wrote:
>> > when support for namespaces
>> 
>> The standard answer is when you add support and get it in, then it
>> will be in.  :-)

> Talking as one who knows *very* little about gcc internals... How big an
> effort are we talking about here?

Significant.

> I would presume the template/namespace twistedness (Koenig rules) is the
> most difficult part...

Nah, that shouldn't be hard once the basic support is there.  Koenig lookup
just means you look up a function in multiple namespaces.  Maybe 10 more
lines of code.  The tricky bit is getting using directives right; the draft
says that a namespace nominated by a using directive is not searched in the
scope where the using directive appears, but rather in the lowest common
denominator of that namespace scope and the current scope.  The
time-consuming bit is going through and fixing all the uses of the current
name lookup stuff.  Here's a design document I put together for later use
in reimplementing scoping.  Anyone is welcome to work on it, or just
comment; I won't be able to work on it for quite a while.

Jason

-------
A more detailed design.  Feedback welcome.

Two "value fields" per id:  unqualified and qualified.  Both are lists.

The unqualified field is a stack of decls for the identifier, in order of
precedence.  Each entry has a level number.  Lookup that just finds types
or labels can scan the stack until it finds something of the proper
variety. Decls check for duplicates in the current level.  At the end of a
block, we walk the block's list of names and pop all the decls in the
current level for each name.  For methods, we set up a single binding level
for the class and its bases.  When defining a class, we set up a binding
level for the bases (using the same code), and another for the class
itself.  Lookup that ignores class scope can step over decls from class
scope (by checking a flag on the stack entry).

For push_to_toplevel we walk down the binding levels, storing the value of
the unqual field for each name used in any of the binding levels, and
skipping the decls lower than namespace scope.  In pop_from_toplevel we
just restore the saved values.

The qualified field is a self-modifying list of namespaces and
corresponding decls.  Perhaps the value field of each node should be a list
to allow for type and non-type values, or perhaps they should just be two
entries in the main list.

We also maintain a stack of used namespaces, along with the level number of
the using directive and the level number of the namespace in question.  If
unqualified lookup passes the level number of one of these namespaces, we
look up the name there before continuing up the unqual stack.  Each
namespace has a list of using-directives, and the nominated namespaces are
also checked.

Perhaps the used namespaces should also be noted in the binding level, so
we can look up a name in two steps: First, look at the first decl hanging
off the identifier.  Then walk the binding levels up to the level of that
decl to find any used namespaces.  If we only kept the stack, we would have
to walk the entire stack for each binding level.

Perhaps failed namespace-level lookups should be cached by adding a
NULL_TREE value for the namespace in question so we don't scan the whole
list of qualified bindings for a name each time we look it up.