如何优化Lisp代码分析？实现macrolet体访问词法作用域规避hack

需求背景 #

需要实现一个Code Walker，在运行时分析表达式，判断是否直接调用了指定函数（比如foo），核心要区分两种情况：

• 真正的函数调用：(let ((x (foo nil))))
• 形似调用的同名绑定：(let ((foo nil)))

之前尝试手动遍历表达式嵌套结构，但无法区分上述两种场景；后来用macrolet配合macroexpand实现了功能，但这种方式像hack（代码如下），希望能有更优雅的实现，比如让macrolet体直接访问外围词法作用域，甚至支持返回所有匹配的调用形式。

原hack实现代码 #

(defmacro find-call (needles haystack)
  (let* ((res (gensym "res"))
         (tag (gensym "tag"))
         (bindings `(,@(mapcar (lambda (spec)
                                 (let ((name (car spec))
                                       (args (cadr spec))
                                       (test (caddr spec)))
                                   `(,name ,args (when-let ((,res ,test))
                                                  (throw ',tag ,res)))))
                               needles)))
    `(catch ',tag
       (macroexpand `(macrolet ,',bindings
                       ,,haystack))
       nil)))

;; 返回 :mark
(find-call ((mark (&rest args) :mark))
  '(mark))
;; 返回 nil
(find-call ((mark (&rest args) :mark))
         '(flet ((mark ()))
            (mark)))

期望的理想实现形式 #

希望有类似macrolet-fun的机制，让macrolet体能访问外围词法作用域，比如：

(defmacro find-call (name expr)
  `(progn
     (macrolet-fun ((,name (&rest args)
                      (return-from contains-call t)))
       expr)
     nil))

解决方案 #

方案1：用动态变量收集匹配结果 #

通过动态变量传递检测状态，结合macrolet在宏展开时捕获目标调用，同时用eval触发表达式展开：

(defvar *detected-calls* nil)

(defmacro find-calls (target-func expr)
  `(let ((*detected-calls* nil))
     (flet ((record-call (func args)
              (push (list func args) *detected-calls*)))
       (macrolet ((,target-func (&rest args)
                    `(progn
                       (record-call ',',target-func ',args)
                       (,',target-func ,@args))))
         (eval (macroexpand-1 ',expr)))
       (nreverse *detected-calls*))))

测试示例：

;; 返回 ((foo nil)) —— 正确识别函数调用
(find-calls foo '(let ((x (foo nil))) x))

;; 返回 nil —— 忽略局部绑定的同名函数
(find-calls foo '(flet ((foo ()))(foo)))

方案2：自定义Code Walker + 词法环境检查 #

如果不想依赖动态变量，可以实现一个自定义Walker，结合macroexpand-1处理宏展开，同时跟踪词法环境来区分同名绑定：

(defun find-direct-calls (target expr &optional env)
  (let ((matches nil))
    (labels ((walk-form (form)
               (cond
                 ;; 原子形式无需处理
                 ((atom form) nil)
                 ;; 引号形式跳过
                 ((eq (car form) 'quote) nil)
                 ;; 处理宏展开
                 ((macro-function (car form) env)
                  (walk-form (macroexpand-1 form env)))
                 ;; 处理特殊运算符，更新词法环境
                 ((special-operator-p (car form))
                  (case (car form)
                    ((let let* flet labels macrolet symbol-macrolet)
                     (let ((new-env (append (mapcar (lambda (binding)
                                                      (list (car binding) :bound))
                                                    (cadr form))
                                            env)))
                       (mapc #'walk-form (cddr form))))
                    (t (mapc #'walk-form (cdr form)))))
                 ;; 检查是否是目标函数调用，且未被词法绑定
                 (t
                  (when (and (eq (car form) target)
                             (not (assoc (car form) env)))
                    (push form matches))
                  (mapc #'walk-form (cdr form))))))
      (walk-form expr)
      (nreverse matches))))

测试示例：

;; 返回 ((foo nil))
(find-direct-calls 'foo '(let ((x (foo nil))) x))

;; 返回 nil
(find-direct-calls 'foo '(flet ((foo ()))(foo)))

方案3：封装成类似macrolet-fun的语法 #

通过宏封装实现你期望的语法风格，利用词法闭包让macrolet体访问外围变量：

(defmacro with-call-detector ((func callback) &body body)
  `(macrolet ((,func (&rest args)
                `(progn
                   (funcall ,',callback ',',func ',args)
                   (,',func ,@args))))
     ,@body))

(defmacro find-call (name expr)
  (let ((found-p (gensym "found-p")))
    `(let ((,found-p nil))
       (with-call-detector (,name (lambda (func args)
                                    (declare (ignore func args))
                                    (setf ,found-p t)))
         (eval (macroexpand-1 ',expr)))
       ,found-p)))

测试示例：

;; 返回 t
(find-call foo '(foo nil))

;; 返回 nil
(find-call foo '(flet ((foo ()))(foo)))

为什么原方案是hack？ #

原方案通过把macrolet嵌入表达式再调用macroexpand，本质是利用宏展开的副作用触发检测，这种方式无法直接访问外围词法环境，只能通过catch/throw传递单一结果，灵活性差。上面的方案要么通过动态变量传递状态，要么通过跟踪词法环境实现精准检测，更符合Code Walker的设计逻辑。

内容的提问来源于stack exchange，提问作者Zoey Hewll