bug#19749:

[Carlos Pita <carlosjosepita@gmail.com>]

Also, you could 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.


On Mon, Feb 9, 2015 at 1:10 PM, Carlos Pita <carlosjosepita@gmail.com> wrote:
> 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