comment #2:

> I have only a weak understanding of how hygienic macros are implemented, but I've always assumed that one would use something like syntactic closures to implement this.  In other words, a macro defined in one library would close over the environment in which it was defined, maintaining access to all the identifiers there.

This is correct and how MIT/GNU Scheme works.

> For references in procedures, rather than in macros, the usual environment mechanism would be used.  Perhaps that means no longer treating top-level definitions specially.

I'm not sure exactly what you mean here.  Let me work with an explicit example.

Suppose we have a macro M in library L1 that expands into code that refers to an identifier I.  M is exported from L1, but I is not.  Suppose also that we have a library L2 that imports M and there is a use of M that generates code referring to I.

I think this is the original problem that you want solved.  If not, speak up.

So the problem here has nothing to do with syntactic expansion; that works as designed.  The problem is, what do we do with the runtime reference to the syntactically-closed identifier I that has been inserted into L2?  There is no means in standard Scheme to resolve this identifier, so I can only conclude that the R7RS working group didn't think about this problem, or else they assumed that the implementation would provide an extra-linguistic mechanism to make it work.

I believe that, whatever mechanism is implemented, it is essentially equivalent to having a "universal environment" in which any identifier in any library can be looked up.

I can think of several mechanisms offhand:

1. Expand each non-local reference of I to (access I (library-environment L1)).
2. Create a "universal environment" and link I to a "universal name" in that environment, e.g. |<L1> <I>|, and expand each non-local reference of I to some code that accesses this.
3. Like (2) but use the global environment, arrange to hide the "universal name" from casual observation, and expand each non-local reference of I to (access |<L1> <I>| #f).

No doubt there are other ways to do this, but they will require more complex changes to the runtime system and compiler.  I think the main issue is that most of this changes will have significant performance consequences.

I've started to develop a solution based on (3), though at the moment it's entirely manual.  See global-ref in "runtime/syntax-rules.scm" for a kludgy working example.  The reason I like this solution is that there's no performance hit at all; the compiler knows how to treat global references specially and they are just as fast as other top-level references.

This is something I've been worried about for years now.

What I don't understand, and maybe the Chibi implementation will tell me, is how one can have a closed reference at runtime.  MIT/GNU Scheme has no simple means to make such a reference, other than transforming the output of the macro so that such references are in effect calls to ACCESS.

Do you have a better idea?