* lisp/emacs-lisp/lisp.el (lisp-completion-at-point): Provide specialized

completion tables when completing error conditions and
`declare' arguments.
(lisp-complete-symbol, field-complete): Mark as obsolete.
(check-parens): Unmatched parens are user errors.
* lisp/minibuffer.el (minibuffer-completion-contents): Mark as obsolete.

4 files changed, 78 insertions, 36 deletions

diff --git a/etc/NEWS b/etc/NEWS
index 0830a7be469..5bf0cb302ff 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -323,7 +323,11 @@ file using `set-file-extended-attributes'.
 
 * Lisp Changes in Emacs 24.4
 
-** `dont-compile' is declared obsolete.
+** Obsoleted functions:
+*** `dont-compile'
+*** `lisp-complete-symbol'
+*** `field-complete'
+*** `minibuffer-completion-contents'
 
 ** `get-upcase-table' is obsoleted by the new `case-table-get-table'.
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index ffa0c840554..4ace42afa09 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,13 +1,22 @@
+2013-04-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/lisp.el (lisp-completion-at-point): Provide specialized
+        completion tables when completing error conditions and
+        `declare' arguments.
+        (lisp-complete-symbol, field-complete): Mark as obsolete.
+        (check-parens): Unmatched parens are user errors.
+        * minibuffer.el (minibuffer-completion-contents): Mark as obsolete.
+
 2013-04-17  Michal Nazarewicz  <mina86@mina86.com>
 
-        * textmodes/flyspell.el (flyspell-check-pre-word-p): Return nil if
-        command changed buffer (ie. `flyspell-pre-buffer' is not current
-        buffer), which prevents making decisions based on invalid value of
-        `flyspell-pre-point' in the wrong buffer.  Most notably, this used to
-        cause an error when `flyspell-pre-point' was nil after switching
-        buffers
-        (flyspell-post-command-hook): No longer needs to change buffers when
-        checking pre-word.  While at it remove unnecessary progn.
+        * textmodes/flyspell.el (flyspell-check-pre-word-p): Return nil if
+        command changed buffer (ie. `flyspell-pre-buffer' is not current
+        buffer), which prevents making decisions based on invalid value of
+        `flyspell-pre-point' in the wrong buffer.  Most notably, this used to
+        cause an error when `flyspell-pre-point' was nil after switching
+        buffers.
+        (flyspell-post-command-hook): No longer needs to change buffers when
+        checking pre-word.  While at it remove unnecessary progn.
 
 2013-04-17  Nicolas Richard  <theonewiththeevillook@yahoo.fr>  (tiny change)
 
diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index 22fb6ad1809..f301a1875ed 100644
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -46,6 +46,12 @@ This affects `insert-parentheses' and `insert-pair'."
   :group 'lisp)
 
 (defvar forward-sexp-function nil
+  ;; FIXME:
+  ;; - for some uses, we may want a "sexp-only" version, which only
+  ;;   jumps over a well-formed sexp, rather than some dwimish thing
+  ;;   like jumping from an "else" back up to its "if".
+  ;; - for up-list, we could use the "sexp-only" behavior as well
+  ;;   to treat the dwimish halfsexp as a form of "up-list" step.
   "If non-nil, `forward-sexp' delegates to this function.
 Should take the same arguments and behave similarly to `forward-sexp'.")
 
@@ -618,9 +624,10 @@ character."
                 ;; "Unbalanced parentheses", but those may not be so
                 ;; accurate/helpful, e.g. quotes may actually be
                 ;; mismatched.
-                (error "Unmatched bracket or quote"))))
+                (user-error "Unmatched bracket or quote"))))
 
 (defun field-complete (table &optional predicate)
+  (declare (obsolete completion-in-region "24.4"))
   (let ((minibuffer-completion-table table)
         (minibuffer-completion-predicate predicate)
         ;; This made sense for lisp-complete-symbol, but for
@@ -645,6 +652,7 @@ considered.  If the symbol starts just after an open-parenthesis, only
 symbols with function definitions are considered.  Otherwise, all
 symbols with function definitions, values or properties are
 considered."
+  (declare (obsolete completion-at-point "24.4"))
   (interactive)
   (let* ((data (lisp-completion-at-point predicate))
          (plist (nthcdr 3 data)))
@@ -666,25 +674,6 @@ considered."
                       (skip-syntax-forward "'")
                       (point))
                   (scan-error pos)))
-           (predicate
-            (or predicate
-                (save-excursion
-                  (goto-char beg)
-                  (if (not (eq (char-before) ?\())
-                      (lambda (sym)          ;why not just nil ?   -sm
-                        (or (boundp sym) (fboundp sym)
-                            (symbol-plist sym)))
-                    ;; Looks like a funcall position.  Let's double check.
-                    (if (condition-case nil
-                            (progn (up-list -2) (forward-char 1)
-                                   (eq (char-after) ?\())
-                          (error nil))
-                        ;; If the first element of the parent list is an open
-                        ;; paren we are probably not in a funcall position.
-                        ;; Maybe a `let' varlist or something.
-                        nil
-                      ;; Else, we assume that a function name is expected.
-                      'fboundp)))))
            (end
             (unless (or (eq beg (point-max))
                         (member (char-syntax (char-after beg)) '(?\" ?\( ?\))))
@@ -694,12 +683,51 @@ considered."
                     (forward-sexp 1)
                     (when (>= (point) pos)
                       (point)))
-                (scan-error pos)))))
+                (scan-error pos))))
+           (funpos (eq (char-before beg) ?\()) ;t if in function position.
+           (table-etc
+            (if (not funpos)
+                ;; FIXME: We could look at the first element of the list and
+                ;; use it to provide a more specific completion table in some
+                ;; cases.  E.g. filter out keywords that are not understood by
+                ;; the macro/function being called.
+                (list nil obarray       ;Could be anything.
+                      :annotation-function
+                      (lambda (str) (if (fboundp (intern-soft str)) " <f>")))
+              ;; Looks like a funcall position.  Let's double check.
+              (save-excursion
+                (goto-char (1- beg))
+                (let ((parent
+                       (condition-case nil
+                           (progn (up-list -1) (forward-char 1)
+                                  (let ((c (char-after)))
+                                    (if (eq c ?\() ?\(
+                                      (if (memq (char-syntax c) '(?w ?_))
+                                          (read (current-buffer))))))
+                         (error nil))))
+                  (pcase parent
+                    ;; FIXME: Rather than hardcode special cases here,
+                    ;; we should use something like a symbol-property.
+                    (`declare
+                     (list t (mapcar (lambda (x) (symbol-name (car x)))
+                                   (delete-dups
+                                    (append
+                                     macro-declarations-alist
+                                     defun-declarations-alist)))))
+                    ((or `condition-case `condition-case-unless-debug)
+                     (list t obarray
+                           :predicate (lambda (sym) (get sym 'error-conditions))))
+                    (_ (list nil obarray #'fboundp))))))))
       (when end
-        (list beg end obarray
-              :predicate predicate
-              :annotation-function
-              (unless (eq predicate 'fboundp)
-                (lambda (str) (if (fboundp (intern-soft str)) " <f>"))))))))
+        (let ((tail (if (null (car table-etc))
+                        (cdr table-etc)
+                      (cons
+                       (if (memq (char-syntax (char-after end))
+                                 '(?\s ?>))
+                           (cadr table-etc)
+                         (apply-partially 'completion-table-with-terminator
+                                          " " (cadr table-etc)))
+                       (cddr table-etc)))))
+          `(,beg ,end ,@tail))))))
 
 ;;; lisp.el ends here
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index 06ac7a91bea..64e816cef38 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -638,7 +638,8 @@ If ARGS are provided, then pass MESSAGE through `format'."
 
 (defun minibuffer-completion-contents ()
   "Return the user input in a minibuffer before point as a string.
-That is what completion commands operate on."
+That used to be what completion commands operate on."
+  (declare (obsolete minibuffer-contents "24.4"))
   (buffer-substring (field-beginning) (point)))
 
 (defun delete-minibuffer-contents ()