How do I force re-evaluation of a defvar?

Question

Suppose I have an Emacs lisp buffer that contains:

(defvar foo 1)

If I call eval-last-sexp or eval-buffer, foo is bound to 1. If I then edit this buffer to:

(defvar foo 2)

eval-last-sexp and eval-buffer do not re-execute this line, so foo is still 1.

This is particularly challenging when there are multiple such statements and I have to track down which lines are not being re-evaluated.

I looked at just restarting Emacs and then (require 'foo), but then I have to be careful to avoid loading any older .elc files.

How can I be absolutely, positively sure that the variables and functions defined in the current file are in the same state as loading code afresh in a new Emacs instance?

Answer 1

As explained in other answers, evaluating a defvar form using eval-last-sexp does not reset the default value.

Instead, you can use eval-defun (bound to C-M-x in emacs-lisp-mode by default), which implements the behaviour you want as a special exception:

If the current defun is actually a call to defvar or defcustom, evaluating it this way resets the variable using its initial value expression even if the variable already has some other value. (Normally defvar and defcustom do not alter the value if there already is one.)

---

If you need to evaluate the full contents of a buffer, you can write a function that walks the top-level forms in turn and calls eval-defun on each. Something like this should work:

(defun my/eval-buffer ()
  "Execute the current buffer as Lisp code.
Top-level forms are evaluated with `eval-defun' so that `defvar'
and `defcustom' forms reset their default values."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (not (eobp))
      (forward-sexp)
      (eval-defun nil))))

Answer 2

Like the other answers say, this is just the way defvar works, but you can get around it, this is elisp after all.

You can temporarily redefine how defvar works if you'd like and during that time, reload the packages you'd like to reset.

I wrote a macro where during the evaluation of the body, defvars values will always be reevaluated.

(defmacro my-fake-defvar (name value &rest _)
  "defvar impersonator that forces reeval."
  `(progn (setq ,name ,value)
          ',name))

(defmacro with-forced-defvar-eval (&rest body)
  "While evaluating, any defvars encountered are reevaluated"
  (declare (indent defun))
  (let ((dv-sym (make-symbol "old-defvar")))
    `(let ((,dv-sym (symbol-function 'defvar)))
       (unwind-protect
           (progn
             (fset 'defvar (symbol-function 'my-fake-defvar))
             ,@body)
         (fset 'defvar ,dv-sym)))))

Example Usage:

file_a.el

(defvar my-var 10)

file_b.el

(with-forced-defvar-eval
  (load-file "file_a.el")
  (assert (= my-var 10))
  (setq my-var 11)
  (assert (= my-var 11)
  (load-file "file_a.el")
  (assert (= my-var 10))

Note: This this should only be used for the purpose of reevaluating defvars, as it just ignores docstrings when reevaluating. You can modify the macro to support re-evaluating that applies docstrings as well, but I will leave that up to you.

In your case you could do

(with-forced-defvar-eval (require 'some-package))

But know what those who write elisp do so expecting defvar to work as specified, it could be they use defvar to define and setq in some init function to specify the value, so you may end up nil'ing variables you don't intend but this is probably rare.

Alternative Implementation

Using this you can just redefine defvar globally and control whether or not it will set the symbol's value to the INIT-VALUE arg even if the symbol is defined by changing the value of the new defvar-always-reeval-values symbol.

;; save the original defvar definition
(fset 'original-defvar (symbol-function 'defvar))

(defvar defvar-always-reeval-values nil
  "When non-nil, defvar will reevaluate the init-val arg even if the symbol is defined.")

(defmacro my-new-defvar (name &optional init-value docstring)
  "Like defvar, but when `defvar-always-reeval-values' is non-nil, it will set the symbol's value to INIT-VALUE even if the symbol is defined."
  `(progn
     (when defvar-always-reeval-values (condition-case nil
         (makunbound ',name)
       (error nil)))
     (original-defvar ,name ,init-value ,docstring)))

;; globally redefine defvar to the new form
(fset 'defvar (symbol-function 'my-new-defvar))

Answer 3

The defvar is being evaluated and doing exactly what you've specified. However, defvar only sets an initial value:

The optional argument INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void.

So to achieve what you want you would either need to unbind the variable before re-evaluating, e.g.

(makunbound 'foo)

or use setq to set the value, e.g.

(defvar foo nil "My foo variable.")
(setq foo 1)

If you don't need to specify a docstring here you can skip the defvar altogether.

If you really want to use defvar and automatically unbind this, you will need to write a function to find defvar calls in the current buffer (or region, or last sexp, etc); call makunbound for each one; and then do the actual eval.

Answer 4

The following macro was created by tracing eval-defun to its supporting functions and modifying it so that it is no longer necessary to evaluate a region of a particular buffer. I needed help in the related thread Converting an expression to a string, and @Tobias came to the rescue -- teaching me how to convert the imperfect function into a macro. I don't think we need eval-sexp-add-defvars to precede elisp--eval-defun-1, but if someone thinks that is important, please let me know.

;;; EXAMPLE:
;;;   (defvar-reevaluate
;;;     (defvar undo-auto--this-command-amalgamating "hello-world"
;;;     "My new doc-string."))

(defmacro defvar-reevaluate (input)
"Force reevaluation of defvar."
  (let* ((string (prin1-to-string input))
        (form (read string))
        (form (elisp--eval-defun-1 (macroexpand form))))
    form))

Answer 5

The problem is not that the line is not getting re-evaluated. The problem is that defvar defines a variable and its default value. If a variable already exists, then changing its default value does not modify the current value. Unfortunately, I think you will need to run a setq for every variable whose value you wish to update.

This may be overkill, but you could update your file like this if you want to be able to easily update foo to its new default value.

(defvar foo 2)
(setq foo 2)

but that requires that you maintain the default value in two places in your code. You could also do this:

(makunbound 'foo)
(defvar foo 2)

but if there is a chance that foo is declared elsewhere you may have some side effects to deal with.