From dd8791e96feb4915c895a4879deee67e672e0a7f Mon Sep 17 00:00:00 2001 From: Stefan Monnier Date: Wed, 17 Apr 2013 16:52:02 -0400 Subject: [PATCH] * 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. --- etc/NEWS | 6 +++- lisp/ChangeLog | 25 ++++++++----- lisp/emacs-lisp/lisp.el | 80 +++++++++++++++++++++++++++-------------- lisp/minibuffer.el | 3 +- 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 + + * 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 - * 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 (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)) " "))) + ;; 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)) " ")))))))) + (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 () -- 2.39.2