Edebug: instrument function without setting breakpoint?

Question

If I have a buffer with the contents

(defun foo()
  (interactive)
  (bar)
  (message "foo"))

(defun bar()
  (interactive)
  (message "bar"))

...and call eval-buffer with edebug-all-defs set to t, then both calls to foo and bar directly throw me into edebug-mode (despite not having set any breakpoints).

On the other hand, if I set edebug-all-defs to nil, evaluate the buffer with eval-buffer and then manually instrument the foo definition with edebug-eval-defun (C-u C-M-x) things work a little better: calling foo invokes the debugger, and calling bar does not. However, when stepping through foo, I'm now unable to step into the bar function (presumably because it hasn't been instrumented, the error is Don't know where `bar' is defined. Stepping over the call to bar works just fine and gives the correct result).

Is there a way to instrument all functions in a buffer without making them breakpoints at the same time?

Emacs 24.4.1 on Debian Jessie. Running with -Q does not seem to make a difference.

Answer 1

So it appears that the problem in this case was related to the function being declared in a buffer which doesn't have a file associated with it, thus Emacs was unable to locate the definition. Here's how I discovered this:

1. I started by looking into the definition of edebug-step-in (I figured out this is the function called in debug mode when I press i for stepping in by inspecting the help page for debug mode (available through pressing ? while in debug mode).
2. Thus I found edebug-instrument-callee, then edebug-instrument-function, then find-function-noselect, then find-function-search-for-symbol, then find-function-library and finally, symbol-file.
3. symbol-file is the same function used to locate the references whenever you see those references highlighted in a help buffer, or when you call describe-function (C-h f).

4. Then I tried to copy what symbol-file does (roughly, just to convince myself that I am on the right track):

   (defun my/defined-in-file (s)
     (car 
      (cl-find-if
       (lambda (x)
         (cl-some
          (lambda (y) (eql s (if (symbolp y) y (cdr y))))
          (cdr x)))
       load-history)))
   
   (my/defined-in-file 'symbol-file)
   "/usr/local/share/emacs/25.0.50/lisp/subr.elc"
   

   The results turned out positive.

5. When I tried to do the same thing with the functions, which were declared in *scratch* buffer, I've got no results.
6. Hence, the conclusion: the automatic instrumentation during "step-in" operation must have failed due to Emacs not being able to locate the source file for the function.

Answer 2

You can step into bar (or any function call) with no previous preparation.

1. eval-buffer (not necessary if everything's already defined).
2. Invoke C-u C-M-x on foo to instrument it.
3. Ivoke M-x foo and you'll be taken immediately into edebug, with point right before the (bar) expression.
4. In edebug, with point right before a function call, you can hit i to instrument and step into that function, even if it was not prevously instrumented.

The i key is described in this manual page. More keys are described here and here.
I also have a couple of blog posts describing the keys I find most useful.

Answer 3

I prefer to debug stuff with lispy instead of Edebug, possibly using Edebug for setup.

For me, the biggest advantage is that I can keep the debug state around, without worrying that if I mistype something in Edebug, all the debug context that I've worked on for 10 minutes will vanish and I would have to start from scratch. It's also great for setting test cases, sinks / mocks etc.

Stepping in and stepping through

You don't need to instrument anything, just press xj or C-x C-j to step in. All the debug state will be kept as global variables. Then just use e or C-x C-e to step.

Using Edebug for setup

If you're debugging a first function call, but actually are interested in how it affects a second function several layers down, just edebug the second function with xe, eval the first function call with e, and you'll end up in Edebug. Press Z to exit in Edebug, while storing the arguments of the current function in global vars. Now, you can continue as before.

If you expect the arguments to be modified in the debug process and don't wish to repeat the setup above, just generate a set of setq statements in *scratch*, so that you can reset them easily.

Starting from:

|(setq foo)

with foo e.g. having the value 42, by typing 2mE you get:

(setq foo
      42|)

• 2m: mark second element of sexp
• E: eval current selection (list or region) and insert the result

The standard equivalent for 2mE would be: M-f M-f SPC C-u C-x C-e.