Odtnhj

I have a macro that intends to creates a closure:

; -*- lexical-binding: t -*-
(defmacro repro ()
 (let ((kmap-sym (gensym "kmap-")))
 `(let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))
 ,kmap-sym)))

;; only works when lexical-binding: t in the current file
(funcall (lookup-key (repro) "a"))

Although lexical-binding is t in the file where the macro is defined, (funcall (lookup-key (repro) "a")) fails with the error (void-variable kmap-30252) whenever it is evaluated in a different file where lexical-binding is nil.

Since I can't control where the macro will be used, I considered going back to using lexical-let for the inner let in the example, which does work regardless of where the macro is invoked.

(defmacro repro ()
 (let ((kmap-sym (gensym "kmap-")))
 `(lexical-let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))
 ,kmap-sym)))

;; this works in any file
(funcall (lookup-key (repro) "a"))

But lexical-let requires cl, which I would like to avoid, and unfortunately lexical-let is not defined in cl-lib.

What options do I have for creating a closure?

Should the macroexpansion of repro always expand into lexical bindings given that lexical-binding is t where the macro is defined?

Not very sure if the result meets your expectation.

(defun foo (keymap)
 `(lambda () (interactive) (message "kmap is %s" ',keymap)))

(defmacro repro ()
 (let ((kmap-sym (gensym "kmap-")))
 `(let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 (foo ,kmap-sym))
 ,kmap-sym)))

(setq lexical-binding nil)
;; => nil

(funcall (lookup-key (repro) "a"))
;; => "kmap is (keymap (97 lambda nil (interactive) (message kmap is %s (quote #0))))"

(setq lexical-binding t)
;; => t

(funcall (lookup-key (repro) "a"))
;; => "kmap is (keymap (97 lambda nil (interactive) (message kmap is %s (quote #0))))"

The following does the same without using a top-level defun.

(defmacro repro ()
 (let ((kmap-sym (gensym "kmap-"))
 (fun (lambda (keymap)
 `(lambda () (interactive) (message "kmap is %s" ',keymap)))))
 `(let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 (,fun ,kmap-sym))
 ,kmap-sym)))

There is an ugly workaround using eval with the optional argument LEXICAL set to t.

(defmacro repro ()
 (let ((kmap-sym (gensym "kmap-")))
 `(eval
 '(let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))
 ,kmap-sym)
 t)))

It is ugly since the associated quoting prevents byte-compilation.

Your example is likely not representative of the actual code you're using, but a good solution might be to create the closure in the macro and return the closure, instead of returning code which may or may not turn into a closure depending on lexical-binding:

(defmacro repro ()
 (let* ((kmap-sym (gensym "kmap-")))
 `(let ((,kmap-sym (make-sparse-keymap)))
 (define-key ,kmap-sym "a"
 ',(lambda () (interactive) (message "kmap is %S" (symbol-value kmap-sym))))
 ,kmap-sym)))

The other option I use nowadays is to do something like

(defmacro ...
 (if (not lexical-binding)
 (error "Macro `foo` can't be used with dynamic binding"))
 ...))

the variable lexical-binding can be relied upon (while expanding the macro) to indicate whether the returned code will be run with lexical or dynamic binding.