(icomplete-eoinput): Remove.

(icomplete-overlay): New var to replace it.
(icomplete-tidy): Rewrite.
(icomplete-exhibit): Use an overlay.
(icomplete-completions): Use completion-all-sorted-completions.
Obey completion-ignore-case.

2 files changed, 34 insertions, 31 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 213cfd9b98a..9d95e7db89a 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,12 @@
 2008-05-22  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+        * icomplete.el (icomplete-eoinput): Remove.
+        (icomplete-overlay): New var to replace it.
+        (icomplete-tidy): Rewrite.
+        (icomplete-exhibit): Use an overlay.
+        (icomplete-completions): Use completion-all-sorted-completions.
+        Obey completion-ignore-case.
+
         * files.el (locate-dominating-file): Accept non-existing argument.
         (project-find-settings-file): Rewrite, using locate-dominating-file.
 
diff --git a/lisp/icomplete.el b/lisp/icomplete.el
index 369342e4d91..cacb7b26f19 100644
--- a/lisp/icomplete.el
+++ b/lisp/icomplete.el
@@ -117,9 +117,9 @@ icompletion is occurring."
 
 ;;;_ + Internal Variables
 ;;;_  = icomplete-eoinput nil
-(defvar icomplete-eoinput nil
-  "Point where minibuffer input ends and completion info begins.")
-(make-variable-buffer-local 'icomplete-eoinput)
+(defvar icomplete-overlay (make-overlay (point-min) (point-min) nil t t)
+  "Overlay used to display the list of completions.")
+
 ;;;_  = icomplete-pre-command-hook
 (defvar icomplete-pre-command-hook nil
   "Incremental-minibuffer-completion pre-command-hook.
@@ -215,15 +215,7 @@ Usually run by inclusion in `minibuffer-setup-hook'."
   "Remove completions display \(if any) prior to new user input.
 Should be run in on the minibuffer `pre-command-hook'.  See `icomplete-mode'
 and `minibuffer-setup-hook'."
-  (when (and icomplete-mode icomplete-eoinput)
-
-    (unless (>= icomplete-eoinput (point-max))
-      (let ((buffer-undo-list t) ; prevent entry
-            deactivate-mark)
-        (delete-region icomplete-eoinput (point-max))))
-
-    ;; Reestablish the safe value.
-    (setq icomplete-eoinput nil)))
+  (delete-overlay icomplete-overlay))
 
 ;;;_ > icomplete-exhibit ()
 (defun icomplete-exhibit ()
@@ -233,9 +225,6 @@ and `minibuffer-setup-hook'."
   (when (and icomplete-mode (icomplete-simple-completing-p))
     (save-excursion
       (goto-char (point-max))
-      ;; Register the end of input, so we know where the extra stuff
-      ;; (match-status info) begins:
-      (setq icomplete-eoinput (point))
                                         ; Insert the match-status information:
       (if (and (> (point-max) (minibuffer-prompt-end))
                buffer-undo-list         ; Wait for some user input.
@@ -250,16 +239,21 @@ and `minibuffer-setup-hook'."
                 ;; embarking on computing completions:
                 (sit-for icomplete-compute-delay)))
           (let ((text (while-no-input
-                        (list
                          (icomplete-completions
                           (field-string)
                           minibuffer-completion-table
                           minibuffer-completion-predicate
-                          (not minibuffer-completion-confirm)))))
+                         (not minibuffer-completion-confirm))))
                 (buffer-undo-list t)
                 deactivate-mark)
             ;; Do nothing if while-no-input was aborted.
-            (if (consp text) (insert (car text))))))))
+            (when (stringp text)
+              (move-overlay icomplete-overlay (point) (point) (current-buffer))
+              ;; The current C cursor code doesn't know to use the overlay's
+              ;; marker's stickiness to figure out whether to place the cursor
+              ;; before or after the string, so let's spoon-feed it the pos.
+              (put-text-property 0 1 'cursor t text)
+              (overlay-put icomplete-overlay 'after-string text)))))))
 
 ;;;_ > icomplete-completions (name candidates predicate require-match)
 (defun icomplete-completions (name candidates predicate require-match)
@@ -281,16 +275,16 @@ The displays for unambiguous matches have ` [Matched]' appended
 matches exist.  \(Keybindings for uniquely matched commands
 are exhibited within the square braces.)"
 
-  (let* ((comps (completion-all-completions name candidates predicate
-                                            (length name)))
-         (last (last comps))
-         (base-size (if (consp last) (prog1 (cdr last) (setcdr last nil))))
+  (let* ((comps (completion-all-sorted-completions))
+         (last (if (consp comps) (last comps)))
+         (base-size (cdr last))
          (open-bracket (if require-match "(" "["))
          (close-bracket (if require-match ")" "]")))
     ;; `concat'/`mapconcat' is the slow part.  With the introduction of
     ;; `icomplete-prospects-length', there is no need for `catch'/`throw'.
-    (if (null comps)
+    (if (not (consp comps))
         (format " %sNo matches%s" open-bracket close-bracket)
+      (if last (setcdr last nil))
       (let* ((most-try
               (if (and base-size (> base-size 0))
                   (completion-try-completion
@@ -299,7 +293,8 @@ are exhibited within the square braces.)"
                 ;; the same with `comps'.
                 (completion-try-completion
                  name comps nil (length name))))
-             (most (if (consp most-try) (car most-try) (car comps)))
+             (most (if (consp most-try) (car most-try)
+                     (if most-try (car comps) "")))
              ;; Compare name and most, so we can determine if name is
              ;; a prefix of most, or something else.
              (compare (compare-strings name nil nil
@@ -320,7 +315,7 @@ are exhibited within the square braces.)"
              (prefix-len
               ;; Find the common prefix among `comps'.
               (if (eq t (compare-strings (car comps) nil (length most)
-                                         most nil nil case-fold-search))
+                                         most nil nil completion-ignore-case))
                   ;; Common case.
                   (length most)
                 ;; Else, use try-completion.
@@ -329,7 +324,7 @@ are exhibited within the square braces.)"
                        (length comps-prefix)))))
 
              prospects most-is-exact comp limit)
-        (if (or (eq most-try t) (null (cdr comps)))
+        (if (eq most-try t) ;; (or (null (cdr comps))
             (setq prospects nil)
           (while (and comps (not limit))
             (setq comp
@@ -339,16 +334,17 @@ are exhibited within the square braces.)"
                   ((member comp prospects))
                   (t (setq prospects-len (+ (length comp) 1 prospects-len))
                      (if (< prospects-len icomplete-prospects-length)
-                         (setq prospects (cons comp prospects))
+                         (push comp prospects)
                        (setq limit t))))))
+        ;; Restore the base-size info, since completion-all-sorted-completions
+        ;; is cached.
+        (if last (setcdr last base-size))
         (if prospects
             (concat determ
                     "{"
                     (and most-is-exact ",")
-                    (mapconcat 'identity
-                               (sort prospects (function string-lessp))
-                               ",")
-                    (and comps ",...")
+                    (mapconcat 'identity (nreverse prospects) ",")
+                    (and limit ",...")
                     "}")
           (concat determ
                   " [Matched"