Something like save-excursion that saves the complete buffer state?

Question

[This question is related to, but not a duplicate of, the question copy contents of current buffer in a temp buffer and operate on that. Besides other incidental things (e.g., the question itself is different), none of the solutions offered both (1) execute the elisp in the same context as the original buffer, AND (2) maintain the state of the original buffer. Indeed, the purpose of the macro offered as a possible solution (with-indirect-buffer-in-foo-mode) in that question seems to be to actually edit the original text in a different mode. The macro also doesn't maintain the buffer-undo-list, of course (nor any other 'state' that may change when the text of a buffer changes).]

I'd like to be able to write

(save-complete-buffer-state
  (edit-the-buffer-arbitrarily)
  (condition-p))

and have everything (or as much as is practical) be preserved from the original emacs buffer state before the call, including, for example, point, kill ring, undo list, etc. Does such a macro already exist? If not, how difficult would it be to implement? (What needs to be saved?)

(I've found c-save-buffer-state at

Emacs: How to intelligently handle buffer-modified when setting text properties?

but I don't know enough about what needs to be done to understand how close this is to doing what I'm asking.)

EDIT: Using lawlist's and @phils' suggestions, I was able to come up with this solution. Please note that this macro works on a few simple test cases but has not been tested extensively.

(defmacro with-cloned-buffer (&rest body)
  "Executes BODY just like `progn' but maintains original buffer state."
  (declare (indent 0))
  (let ((return-value (make-symbol "return-value")))
    `(let (buffer-undo-list)   ;  maintain original buffer-undo-list
       (clone-indirect-buffer nil t)
       (let ((,return-value (progn ,@body)))
         (primitive-undo 1 buffer-undo-list)
         (kill-buffer-and-window)
         ,return-value))))

Here are two simple tests (first returns t, second returns nil):

(with-cloned-buffer
  (insert "A")
  (left-char 1)
  (looking-at-p "A"))

(with-cloned-buffer
  (insert "A")
  (left-char 1)
  (looking-at-p "B"))

Answer 1

Your suggested solution confuses things more than anything: clone-indirect-buffer creates another buffer which shares the same text, so any changes to the text in the clone will also affect the original buffer, so you haven't gained anything, really. Maybe you'd be better served with clone-buffer (not indirect).

Using a temp buffer might be a good idea, but then you'd presumably want that other buffer to have its own copy of the contents, so you'd do something like:

(let ((orig-buf (current-buffer)))
  (with-temp-buffer
    (insert-buffer-substring orig-buffer)
    <do-your-thing>))

Of course, this can suffer from other problems, such as the fact that the temp buffer is not configured in the same major/minor modes as the original one.

Another option would be to stay in the same buffer and instead undo the changes at the end, using atomic-change-group, e.g.:

(catch 'done
 (atomic-change-group
  <do-your-thing>
  (throw 'done <result>)))

Answer 2

I appreciate all the suggestions offered by everyone. Using them I have created three different macros with very similar (but not completely identical) functionality that do what I want. Note that the macro named with-cloned-buffer below is not the same as the macro with that name in my question. Also be aware that while these macros have all been tested on toy examples, they have not been tested extensively yet.

Except for the name, this is the same macro as in the question and uses clone-indirect-buffer:

(defmacro with-cloned-indirect-buffer (&rest body)
  "Executes BODY just like `progn' but maintains original buffer state."
  (declare (indent 0))
  (let ((return-value (make-symbol "return-value")))
    `(let (buffer-undo-list)   ;  maintain original buffer-undo-list
       (clone-indirect-buffer nil t)
       (let ((,return-value (progn ,@body)))
         (primitive-undo 1 buffer-undo-list)
         (kill-buffer-and-window)
         ,return-value))))

Using clone-buffer instead of clone-indirect-buffer:

(defmacro with-cloned-buffer (&rest body)
  "Executes BODY just like `progn' but maintains original buffer state."
  (declare (indent 0))
  (let ((return-value (make-symbol "return-value")))
    `(let ((buffer-file-name nil))
       (clone-buffer nil t)
       (let ((,return-value (progn ,@body)))
         (kill-buffer-and-window)
         ,return-value))))

Using atomic-change-group:

(defmacro save-buffer-state (&rest body)
  "Executes BODY just like `progn' but maintains original buffer state."
  (declare (indent 0))
  (let ((return-value (make-symbol "return-value")))
    `(catch 'done
       (atomic-change-group
         (let ((,return-value (progn ,@body)))
           (throw 'done ,return-value))))))

A couple notes. In spirit, the last version is my favorite, except that it doesn't maintain buffer-local variables. I'd actually prefer something that maintained all variables, but that's probably too much to ask.

Second, the atomic-change-group version can easily be tweaked to make a macro that runs editing code conditionally. One possibility is that the edits are kept if the last form returns a truthy value. (This is, of course, similar to atomic-change-group itself.)

Third, although it's very clean, using clone-buffer seems inefficient for the use-case I have in mind: testing small edits on possibly big buffers.

Finally, at least the first two macros would be better if they incorporated unwind-protect.

Practically speaking, assuming I haven't made any big programming errors, all three solve the problem I was hoping to solve. Thanks, everyone!