Bug in completing-read

Bug in completing-read

[Luc Teirlinck]

If one evaluates:

(read-from-minibuffer "Input: " '("123456789" . 3))

point appears on the "3" in the minibuffer.

But if one evaluates:

(completing-read "Input: " '("123456789") nil nil '("123456789" . 3))

point appears on the "4" in the minibuffer.

This is inconsistent and it also contradicts the documentation string
of `completing-read'.  In other words, the behavior of
`completing-read' is an obvious bug.  It is trivial to fix, in fact I
"inadvertently" fixed it in my own private Emacs.  

In another thread ("read-from-minibuffer and friends"), I proposed a
patch that will move the handling of string-integer conses of the type
used above from Fread_from_minibuffer into read_minibuf.  (Not yet
installed because of the Savannah situation.)  After proposing that
patch I made some small further changes.  (I got rid of variables that
were no longer used, but which I inadvertently forgot to remove.)  But
then I noticed nearly identical code in Fcompleting_read.  I removed
this now redundant code.  But while diffing I noticed that a "-1" was
missing in a formula in the removed code.  At first sight, wonderful.
Code gone, bug gone, end of story.  Now the problem.

People using such arguments to `completing-read' apparently found it
easier to just get around the bug by putting the "-1" in their own
code, rather than reporting it or fixing it in minibuf.c.

So now we are left with the following choice:

1.  Document this inconsistency in the documentation string of
    `completing-read', as well as in the Elisp manual, and say that it
    exists for historical compatibility.  (I could do that, if that is
    what we decide to do.)

2.  Fix the bug and also fix existing code that relies on the bug.  (I
    could trivially fix the bug, if that is what we decide to do.  As
    mentioned above, I have already fixed it in my personal Emacs.
    Finding _all_ code relying on the bug seems very non-trivial,
    however, because `completing-read' is used so often.)

Example:

M-x load-library RET ffap

M-: (ffap-read-file-or-url "Input: " "myfile") RET

Result:

Input: ~/emacscvsdir/emacs/lisp/myfile

with point on the `m' of myfile, as probably intended.  Fixing the bug
in `completing-read' would put it on the last `/'.

So do we fix this bug or make the inconsistency an "official, but
deprecated, feature" by documenting it?

Sincerely,

Luc.

Re: Fixed bug in completing-read

[Luc Teirlinck]

I have fixed (in CVS) the bug I in `completing-read' which I reported
in my previous message.  Some packages may _rely_ on the bug.  This
concerns the initial position of point in an inserted default string
after entering the minibuffer.  In the (rare) case where the INITIAL
argument to `completing-read' is a cons of a string and an integer (as
opposed to just a string),`completing-read' used to put point one
positiom more to the right than `read-from-minibuffer', contradicting
its own documentation string.

This is now fixed.  There is no change in the (usual) case where
INITIAL is just a string: point appears at the end of the inserted
string.  In nearly all cases where initial is a cons, the purpose was
to make point appear at the _beginning_ of the inserted string.  To
get around the bug, many packages specified a position of 0 instead of
1.  This is *no problem*.  _Any_ integer 1 _or_ less puts point at the
beginning of the string.  The *only* time there is a problem is when
one tries to put point somewhere in the _middle_ of the inserted
string.  In that case, point will now appear one position more to the
_left_ than intended.  This can trivially be fixed by adding 1 to the
formula computing the position.  I fixed the one single example I knew
of.  However, the number of calls to `completing-read' is so huge and
many calls are so complex, that it is impossible to be certain that
there are no other cases.  So, if after entry to the minibuffer, on a
function that provides completion, point appears one position too far
to the left in the pre-inserted string, you know what the problem is
and it is trivial to fix.

Sincerely,

Luc.