procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert the changes to lisp-current-defun-name

Browse source 
* lisp/emacs-lisp/lisp-mode.el (lisp-current-defun-name): Revert
back to the old version before bug#49592.  The new approach just
doesn't work well enough -- we don't really have the data to know
that, say, `make-obsolete-variable' is about the second symbol and
not the first.
This commit is contained in:
Lars Ingebrigtsen 2022-08-23 12:26:24 +02:00
parent 9d9798521e
commit 48b0f2606b
1 changed files with 18 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

73
lisp/emacs-lisp/lisp-mode.el
View file

@ -728,67 +728,30 @@ font-lock keywords will not be case sensitive."
len))))
(defun lisp-current-defun-name ()
"Return the name of the defun at point.
If there is no defun at point, return the first symbol from the
top-level form. If there is no top-level form, return nil.
(\"defun\" here means \"form that defines something\", and is
decided heuristically.)"
"Return the name of the defun at point, or nil."
(save-excursion
(let ((location (point))
name)
(let ((location (point)))
;; If we are now precisely at the beginning of a defun, make sure
;; beginning-of-defun finds that one rather than the previous one.
(unless (eobp)
(forward-char 1))
(or (eobp) (forward-char 1))
(beginning-of-defun)
;; Make sure we are really inside the defun found, not after it.
(when (and (looking-at "(")
(progn
(end-of-defun)
(< location (point)))
(progn
(forward-sexp -1)
(>= location (point))))
(when (looking-at "(")
(forward-char 1))
;; Read the defining construct name, typically "defun" or
(when (and (looking-at "\\s(")
(progn (end-of-defun)
(< location (point)))
(progn (forward-sexp -1)
(>= location (point))))
(if (looking-at "\\s(")
(forward-char 1))
;; Skip the defining construct name, typically "defun" or
;; "defvar".
(let ((symbol (ignore-errors (read (current-buffer)))))
(when (and symbol (not (symbolp symbol)))
(setq symbol nil))
;; If there's an edebug spec, use that to determine what the
;; name is.
(when symbol
(let ((spec (or (get symbol 'edebug-form-spec)
(and (eq (get symbol 'lisp-indent-function) 'defun)
(get 'defun 'edebug-form-spec)))))
(save-excursion
(when (and (eq (car-safe spec) '&define)
(memq 'name spec))
(pop spec)
(while (and spec (not name))
(let ((candidate (ignore-errors (read (current-buffer)))))
(when (eq (pop spec) 'name)
(when (and (consp candidate)
(symbolp (car (delete 'quote candidate))))
(setq candidate (car (delete 'quote candidate))))
(setq name candidate
spec nil))))))))
;; We didn't have an edebug spec (or couldn't find the
;; name). If the symbol starts with \"def\", then it's
;; likely that the next symbol is the name.
(when (and (not name)
(string-match-p "\\(\\`\\|-\\)def" (symbol-name symbol)))
(when-let ((candidate (ignore-errors (read (current-buffer)))))
(cond
((symbolp candidate)
(setq name candidate))
((and (consp candidate)
(symbolp (car (delete 'quote candidate))))
(setq name (car (delete 'quote candidate)))))))
(when-let ((result (or name symbol)))
(and (symbolp result) (symbol-name result))))))))
(forward-sexp 1)
;; The second element is usually a symbol being defined. If it
;; is not, use the first symbol in it.
(skip-chars-forward " \t\n'(")
(buffer-substring-no-properties (point)
(progn (forward-sexp 1)
(point)))))))
(defvar-keymap lisp-mode-shared-map
:doc "Keymap for commands shared by all sorts of Lisp modes."