Re: syntax-local-value patch for discussion

[Stefan Israelsson Tampe]

Ok, I have tried follow your suggestion, 
here is what I could make,

        (with-fluids ((*macro-lookup*
                       (lambda (e)
                         (cond
                          ((number? e)
                           (pk w))
                             
                          ((symbol? e)
                           (lookup (id-var-name e w)
                                   r mod))

                          ((syntax-object? e)
                           (lookup (id-var-name 
                                    (syntax-object-_expression_ e)
                                    (syntax-object-wrap e))  
                                   r
                                   (or 
                                    (syntax-object-module e)
                                    mod)))
                          (else #f)))))

just look at the syntax-object? part for now. You will see that I only use
syntax-object-wrap and not the joining with w which fails when I try to do that using e.g.
 ((syntax-object? e)
          (syntax-type (syntax-object-_expression_ e)
                       r
                       (join-wraps w (syntax-object-wrap e))
                       (or (source-annotation e) s) rib
                       (or (syntax-object-module e) mod) for-car?))

which is the syntax? part of the syntax-type function. Hence I tried
 (join-wraps w (syntax-object-wrap e))

but that does not work. 

comments?

/Stefan

On Sun, Jan 8, 2012 at 8:15 PM, Mark H Weaver <address@hidden> wrote:

Hi Stefan,

Stefan Israelsson Tampe <address@hidden> writes:

> diff --git a/module/ice-9/psyntax.scm b/module/ice-9/psyntax.scm
> index e522f54..70463a5 100644
> --- a/module/ice-9/psyntax.scm
> +++ b/module/ice-9/psyntax.scm
> @@ -155,6 +155,10 @@
>  (eval-when (compile)
>    (set-current-module (resolve-module '(guile))))
>
> +(define *macro-lookup* (make-fluid))
> +(fluid-set! *macro-lookup*
> +            (lambda x (error "not in a macro evaluation context")))
> +
>  (let ()
>    (define-syntax define-expansion-constructors
>      (lambda (x)
> @@ -1304,8 +1308,12 @@
>                     (syntax-violation #f "encountered raw symbol in macro output"
>                                       (source-wrap e w (wrap-subst w) mod) x))
>                    (else (decorate-source x s)))))
> -        (rebuild-macro-output (p (source-wrap e (anti-mark w) s mod))
> -                              (new-mark))))
> +        (with-fluids ((*macro-lookup*
> +                       (lambda (e) (lookup (id-var-name e w)
> +                                           r mod))))
> +
> +          (rebuild-macro-output (p (source-wrap e (anti-mark w) s mod))
> +                                (new-mark)))))
>
>      (define expand-body
>        ;; In processing the forms of the body, we create a new, empty wrap.

This doesn't look quite right to me.

At this one point only, where a macro is expanded, you capture the
lexical environment (r w mod) in your fluid.  This is the lexical
environment that you use to lookup plain symbols later passed to
`syntax-binding-info'.

Will this approach will be robust in the general case?  For example,
what happens if you use a macro in one module to generate a macro in
another module that uses syntax-binding-info on a syntax object that
came from yet another module?

A few suggestions:

First, as others have pointed out, you should be passing syntax-objects
to `syntax-binding-info' instead of plain symbols.  This one change
alone will make this code far robust, because syntax-objects include
their own wrap and module.

Second, in your call to `lookup', you should pass the module that came
from the syntax-object, instead of the module captured from the most
recent macro expansion.  Please take a look at how psyntax's internal
procedure `syntax-type' looks up syntax-objects (compared with how it
looks up plain symbols).  I think you should emulate that logic.

Third, are you sure that the `r' captured from the most recent macro
expansion will be recent enough in all cases to include the binding
that's being queried?  `r' is extended in quite a few places in psyntax,
for various different binding constructs.

     Best,
      Mark