Subject: bug#19749:

From: Carlos Pita <[email-masked]>
Date: Mon, 9 Feb 2015 13:10:24 -0300

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))

Cheers
--
Carlos