How to override a function in a function only in that function?

Question

I used (advice-add 'yas-new-snippet :override 'my/yas-new-snippet ) but I was wondering if there was something like this which would allow me to override a function in a function only in that function:

(override-func 'yas-new-snippet 'switch-to-buffer 'switch-to-buffer-other-window)

What I did was override the function to open the snippet in another window. This works but assume that the package maintainer is actively maintaining. I would have to copy this when/if it gets updated. Fortunately for me yas does not get updates frequently. Another thing is that it adds more code to my config.

(defun my/yas-new-snippet (&optional no-template)
  "Pops a new buffer for writing a snippet.

Expands a snippet-writing snippet, unless the optional prefix arg
NO-TEMPLATE is non-nil."
  (interactive "P")
  (let ((guessed-directories (yas--guess-snippet-directories))
        (yas-selected-text (or yas-selected-text
                               (and (region-active-p)
                                    (buffer-substring-no-properties
                                     (region-beginning) (region-end))))))

    ;;(switch-to-buffer yas-new-snippet-buffer-name)
    (switch-to-buffer-other-window yas-new-snippet-buffer-name)
    (erase-buffer)
    (kill-all-local-variables)
    (snippet-mode)
    (yas-minor-mode 1)
    (set (make-local-variable 'yas--guessed-modes)
         (mapcar (lambda (d) (yas--table-mode (car d)))
                 guessed-directories))
    (set (make-local-variable 'default-directory)
         (car (cdr (car guessed-directories))))
    (if (and (not no-template) yas-new-snippet-default)
        (yas-expand-snippet yas-new-snippet-default))))

;; Open new snippet in other window.
(advice-add 'yas-new-snippet :override 'my/yas-new-snippet )

Answer 1

Expanding @lawlist's comment above, here's how to do it with cl-letf.

Let's start with a simple example: you have a function foo which calls a function bar with an argument (foo is the analog of the yas-new-snippet function in your case and bar is the analog of switch-to-buffer) and I want to change foo to call a different function baz instead (the analog of switch-to-buffer-other-window in your case), but from the "outside". So here are the three functions:

  (defun foo ()
    (bar "foo"))

  (defun bar (x)
    (message (format "%s:%s" "bar" x)))

  (defun baz (x)
    (message (format "%s:%s" "baz" x)))

  (foo) ---> "bar:foo"

Define a new function that (effectively) calls baz instead of bar - that's the analog of your my/yas-new-snippet function:

  (defun my/foo ()
    (cl-letf (((symbol-function 'bar) #'baz))
      (foo)))

Now when I call my-foo, it calls baz instead of bar:

(my-foo) ----> "baz:foo"

Note that we are not touching foo at all. We are just temporarily modifying the function cell of the bar symbol to hold the baz function instead. We then call foo which thinks it's calling bar, but we have pulled a switcheroo and it's (effectively) calling baz instead. And then we are out of scope of cl-letf and everything is back the way it was.

So in your case, you can do this:

(defun my/yas-new-snippet (&optional no-template)
  (interactive "P")
  (cl-letf (((symbol-function 'switch-to-buffer) #'switch-to-buffer-other-window))
     (yas-new-snippet no-template)))

I haven't actually tested this (I did test the toy example above), so I hope this works but I'm reasonably sure that it will. EDIT: As the OP points out in a comment, in order for the new function to be compatible with the old function, not only does it have to have the same signature, but it also has to have the same interactive specification, so that the optional argument is handled the same way.

Since we are using the old yas-new-snippet function inside the new function, you should not override the old function with the new one: that would cause an infinite descent. The new function calls the old functions so you need both functions to stick around in Emacs's memory. Instead of the overriding advice, just bind the new function to whatever key the old function was bound to.

Here's a question with more information and here is Malabarba's article that is linked from one of the answers to that question. I found both of these very illuminating.