bug#19748: python.el: navigate to beginning of defun gets stucked

bug#19748: python.el: navigate to beginning of defun gets stucked

[Carlos Pita]

[-- Attachment #1: Type: text/plain, Size: 1251 bytes --]

This report is for python.el in the current master
(c10828bd8520db83cc06a2ad5de6f8a1ad74b83c).

Pressing C-M-a one time correctly positions the point at the beginning
of the current class or defun statement. Pressing C-M-a multiple times
is futile, as the point gets stucked where the first movement left
it. This is not consistent with the usual emacs behavior and it's not
very convenient to navigate code anyway.

The problem is in python-nav--beginning-of-defun:

            (when (and (> arg 0)
                       (python-info-looking-at-beginning-of-defun))
              (end-of-line 1))

This puts the point at the end of the line when the point is at a defun
or class line and the navigation is backward. So the next
re-search-backward will match the current line. This is fine when the
point is *after* the column where the defun or class statement starts,
but not quite so when the point is *over the indentation* whitespace
(that is, before the beginning of the defun/class keyword).

One simple solution is to add another condition:

            (when (and (> arg 0)
                       (> (current-column) (current-indentation))
                       (python-info-looking-at-beginning-of-defun))
              (end-of-line 1))


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: patch --]
[-- Type: text/x-diff, Size: 518 bytes --]

diff --git a/.emacs.d/lisp/python.el b/.emacs.d/lisp/python.el
index 788d09f..ca69b68 100644
--- a/.emacs.d/lisp/python.el
+++ b/.emacs.d/lisp/python.el
@@ -1295,6 +1295,7 @@ With positive ARG search backwards, else search forwards."
          (found
           (progn
             (when (and (> arg 0)
+                       (> (current-column) (current-indentation))
                        (python-info-looking-at-beginning-of-defun))
               (end-of-line 1))
             (while (and (funcall re-search-fn

bug#19748: python.el: navigate to beginning of defun gets stucked

[Fabián Ezequiel Gallina]

This doesn't happen with master's python.el.

The regression you are experiencing seems to be happening because you
are working on a patched python.el version that includes the change you
proposed in http://debbugs.gnu.org/cgi/bugreport.cgi?bug=19665


Cheers,
Fabián.

bug#19748:

[Carlos Pita]

Sorry for reopening this, Fabián. You're right in pointing that this
bug was introduced by my fix to 19665. But AFAICS 19665 is indeed a
bug: you want to go to the end of the defun line when the search is
backward, in order to match arg defun including the current one.

There is a more difficult problem here. Say * is the point:

1) You want C-M-a to move the point from def* to *def.

2) You want C-M-a to mode the point from *def to the previous definition.

(1) is addressed by 19665.
(2) is addressed by this report.

Still, there is:

3) You want C-M-h both in def* and in *def to select the current
defun. 19665 was intended to correct both cases (*def and def*), but
my patch here breaks again the case *def (because for *def the
selection reverts now to the pathological behavior described in 19665,
just because of the additional condition in the guard, which should be
kept anyway because of (2)).

Note: I'm checking my assertions 1, 2 and 3 against the standard
behavior of elisp mode, which I take as a reference. That's indeed the
behavior there.

More briefly: for C-M-a you want to distinguish between def* and *def,
but for C-M-h you don't. The previous fix here and 19665 correctly
address (1) and (2), and mostly address (3) except for the corner case
*class, which I address in what follows.

Looking at the definition of mark-defun one could clearly see what the
problem is. Starting from *class, say, mark-defun will mark the
previous defun and then check (if (> (point) opoint) to see that the
selected defun was not the desired one. So it goes through the else
part sending the point to the end of the class block and then moving
backward one defun to select just the last method. I think we could
fix this tweaking a bit the behavior of mark-defun, but -unusually-
mark-defun allows for no local extension points. A simple advice could
do the trick but I don't feel like adding an advice just for python
sake to a globally and often used function. The last option I'm able
figure out is to replace mark-defun in the python keymap. This is not
perfect, as mark-defun could be used programatically also, but I
believe it's good enough:

(define-key map [remap mark-defun] 'python-mark-defun)

(defun python-mark-defun ()
  (interactive)
  (when (python-info-looking-at-
beginning-of-defun)
    (end-of-line 1))
  (mark-defun))

Besides that, I want to emphazise that you still need:

-            (when (and (< arg 0)
+            (when (and (> arg 0)

and

+                       (> (current-column) (current-indentation))


Also, you may want to set allow-extend for mark-defun.

I will post a patch to 19665 including the original change and the
mark-defun fix.

The  (> (current-column) (current-indentation)) fix in this report
remains valid except you worked out a cleaner solution for 1, 2 and 3
above.