175 lines
6.0 KiB
Racket
175 lines
6.0 KiB
Racket
#lang racket
|
|
|
|
;; For a more realistic use-case justifying why this behaviour matters, see the
|
|
;; discussion at https://github.com/jackfirth/generic-syntax-expanders/pull/8
|
|
;; and in particular the test file at
|
|
;; https://github.com/jsmaniac/generic-syntax-expanders
|
|
;; /blob/ec43791028715221c678f8536389a39ee760ed98
|
|
;; /test/test-define-x-expander-use-site-scope.rkt
|
|
|
|
(require generic-syntax-expanders
|
|
rackunit)
|
|
|
|
(define-expander-type foo)
|
|
|
|
(define-syntax (expand-foos stx)
|
|
(syntax-case stx ()
|
|
[(_ body)
|
|
(expand-all-foo-expanders #'body)]))
|
|
|
|
;; Without PR #8, the `x` in `bb` is not `bound-identifier=?` to the `x`
|
|
;; defined by `aa`, despite the use of `syntax-local-introduce` to make the
|
|
;; macros unhygienic.
|
|
;;
|
|
;; This happens because `define-foo-expander` added an extra "use-site" scope
|
|
;; to the body of `aa` and a different "use-site" scope to the body of `bb`.
|
|
(define-foo-expander aa
|
|
(λ (_)
|
|
(syntax-local-introduce #'[x #t])))
|
|
|
|
(define-foo-expander bb
|
|
(λ (_)
|
|
(syntax-local-introduce #'x)))
|
|
|
|
;; Due to the way `let` itself adds scopes to its definition and body, this
|
|
;; makes the identifiers `x` from `aa` and `x` from `bb` distinct, and the
|
|
;; latter cannot be used to refer to the former.
|
|
;;
|
|
;; Approximately, the code below expands to
|
|
;;
|
|
;; (let [(x⁰¹ #t)]
|
|
;; x⁰²)
|
|
;;
|
|
;; The `let` form then adds a "local" scope to both occurrences of `x`, and an
|
|
;; internal-definition context "intdef" scope to the `x` present in the body of
|
|
;; the `let` (but not to the one present in the bindings). The expanded form
|
|
;; therefore becomes:
|
|
;;
|
|
;; (let [(x⁰¹³ #t)]
|
|
;; x⁰²³⁴)
|
|
;;
|
|
;; where:
|
|
;; ⁰ are the module's scopes
|
|
;; ¹ is the undesired "use-site" scope added by `define-foo-expander` on `aa`
|
|
;; ² is the undesired "use-site" scope added by `define-foo-expander` on `bb`
|
|
;; ³ is the "local" scope added by `let`
|
|
;; ⁴ is the "intdef" scope added by `let`
|
|
;;
|
|
;; Since {0,2,3,4} is not a subset of {0,1,3}, the `x` inside the `let` is
|
|
;; unbound.
|
|
(test-true
|
|
"Test that `x` as produced by `(bb)` is correctly bound by the `x`
|
|
introduced by `(aa)`.
|
|
|
|
This test fails without the PR #8 patch, because the body of `bb` and the body
|
|
of `aa` each have a different use-site scope, introduced by accident by
|
|
`define-foo-expander`. The occurrence of `x` introduced by `aa` and the
|
|
occurrence of `x` introduced by `bb` therefore have different scopes, and the
|
|
latter is not bound by the former.
|
|
|
|
Without the PR #8 patch, this test case will not compile, and will fail with
|
|
the error `x: unbound identifier in module`."
|
|
(expand-foos
|
|
(let ((aa))
|
|
(bb))))
|
|
|
|
;; ----------
|
|
|
|
;; It is worth noting that `define` seems to strip the "use-site" scopes present
|
|
;; on the defined identifier. If the code above is changed so that a `define`
|
|
;; form is used, the problem does not occur:
|
|
(define-foo-expander aa-def
|
|
(λ (_)
|
|
(syntax-local-introduce #'[define y #t])))
|
|
|
|
(define-foo-expander bb-def
|
|
(λ (_)
|
|
(syntax-local-introduce #'y)))
|
|
|
|
;; This is because the code below expands to:
|
|
;;
|
|
;; (begin (define y⁰ #t)
|
|
;; (define y-copy y⁰²⁵)
|
|
;;
|
|
;; where:
|
|
;; ⁰ are the module's scopes
|
|
;; ¹ is the undesired "use-site" scope added by `define-foo-expander` on `aa`
|
|
;; and it is stripped by `define` from the first `y`
|
|
;; ² is the undesired "use-site" scope added by `define-foo-expander` on `bb`
|
|
;; ⁵ is the "use-site" scope added because it is in an expression position
|
|
;;
|
|
;; Since {0,2,5} is a subset of {0}, the second `y` refers to the first `y`.
|
|
(expand-foos
|
|
(begin (aa-def)
|
|
(define y-copy (bb-def))))
|
|
(test-true
|
|
"Test that `y` as produced by `(bb-def)` is correctly bound by the `y`
|
|
defined by `(aa-def)`.
|
|
|
|
This test succeeds without the PR #8 patch, which shows that `define` removes
|
|
all use-site scopes on the defined identifier (or at least it removes all the
|
|
use-site scopes present in this example). This can be checked in the macro
|
|
debugger, and explains why the test case did not fail with a simple `define`,
|
|
but does fail with a binding introduced by a `let`."
|
|
y-copy)
|
|
|
|
;; ----------
|
|
|
|
;; The code below attempts to remove the extra "use-site" scope with
|
|
;; `syntax-local-identifier-as-binding`. However, that function does
|
|
;; not remove all use-site scopes, unlike the `define` above.
|
|
|
|
(define-foo-expander aa-as-binding
|
|
(λ (_)
|
|
#`[#,(syntax-local-identifier-as-binding (syntax-local-introduce #'z)) #t]))
|
|
|
|
(define-foo-expander bb-as-binding
|
|
(λ (_)
|
|
(syntax-local-introduce #'z)))
|
|
|
|
(test-true
|
|
"Test that `z` as produced by `(bb-as-binding)` is correctly bound by
|
|
the `z` defined by `(aa-as-binding)`.
|
|
|
|
This test fails without the PR #8 patch, which shows that that unlike `define`,
|
|
the `syntax-local-identifier-as-binding` function does not remove all use-site
|
|
scopes.
|
|
|
|
Without the PR #8 patch, this test case will not compile, and will fail with
|
|
the error `z: unbound identifier in module`."
|
|
(expand-foos
|
|
(let ((aa-as-binding))
|
|
(bb-as-binding))))
|
|
|
|
;; ----------
|
|
|
|
;; The `cc` expander acts either as aa or as bb depending on the keyword passed
|
|
;; to it. Without PR #8, the code below still compiles fine.
|
|
;;
|
|
;;
|
|
;; The fact that it worked without the patch testifies that the extra scope
|
|
;; was added on the definition of `aa` and `bb`, instead of being a new fresh
|
|
;; scope added each time the expander is called. Here, we have two calls to
|
|
;; the `cc` expander successfully communicating via the `w` variable, thanks
|
|
;; to `syntax-local-introduce` (which makes the macros unhygienic).
|
|
(define-foo-expander cc
|
|
(λ (stx)
|
|
(syntax-case stx ()
|
|
[(_ #:aa)
|
|
(begin
|
|
(syntax-local-introduce #'[w #t]))]
|
|
[(_ #:bb)
|
|
(begin
|
|
(syntax-local-introduce #'w))])))
|
|
|
|
(test-true
|
|
"Test that `w` as produced by `(cc #:bb)` is correctly bound by the `w`
|
|
introduced by `(cc #:aa)`.
|
|
|
|
This test succeeds without the PR #8 patch, which shows that the extra
|
|
scopes are per-expander and not per-invocation. Expanders can still be
|
|
unhygienic using `syntax-local-introduce`, but can communicate only with
|
|
themselves."
|
|
(expand-foos
|
|
(let ((cc #:aa))
|
|
(cc #:bb)))) |