anchor.diff:                              `((,macro? (,def) ,@(expand-top (rest forms)))))
                              ((nil)
                               (cons exp (expand-top (rest forms)))))))))
  -               (extract-special-macro-arg (sym args)
  -                 "Extract an argument (like `&environment' or `&whole') from a macro lambda list.
  -If the argument is not present, return a gensym."
  -                 (assert (char= (aref (string sym) 0) #\&))
  -                 (if-let (tail (member sym args))
  -                   (values (cadr tail)
  -                           (append (ldiff args tail) (cddr tail)))
  -                   (values (gensym)
  -                           args)))
  -               (compile-macro-function (args body)
  -                 "Compile a macro function into a form acceptable to `augment-environment.'"
  -                 (multiple-value-bind (env-var args)
  -                     (extract-special-macro-arg '&environment args)
  -                   (multiple-value-bind (whole-var args)
  -                       (extract-special-macro-arg '&whole args)
  -                     (compile nil (eval `(lambda (,whole-var ,env-var)
  -                                           (declare (ignorable ,env-var ,whole-var))
  -                                           (destructuring-bind ,args (rest ,whole-var)
  -                                             ,@body)))))))
                  (expand-1 (form env)
                    "Like macroexpand-1 with local macro and symbol macro definitions."
                    (match form
  
positive.code:                       (values (second match) t)
                        (macroexpand-1 form env)))
                     ((list* (and name (type symbol)) _)
                      (if-let (match (assoc name macro-fns))
                        (values (funcall (second match) form env) t)
                        (macroexpand-1 form env)))
                     (otherwise
                      (macroexpand-1 form env))))
                 (expand (form env)
  
negative.code:                                 `(progn (setf ,var ,expr) ',var)))))
                         ((defconstant name expr &optional docstring)
                          (declare (ignore docstring))
                          (let ((expanded (expand expr env)))
                            (if (and (not (in-env?)) (constantp expanded))
                                (expand-partially
                                 `(define-symbol-macro ,name ,expr))
                                (push (list name `(load-time-value ,expr t)) hoisted-vars)))
                          `',name)
                         ((defconst name expr &optional docstring)
                          (expand-partially `(defconstant ,name ,expr ,docstring)))
                         ((defun name args &body body)
                          (if (in-env?)
                              (expand-partially
                               `(defalias ,name
                                  (named-lambda ,name ,args
  