8 files changed, 200 insertions, 109 deletions

diff --git a/lisp/progmodes/eglot.el b/lisp/progmodes/eglot.el
index 80099a26ee8..4752b0100d9 100644
--- a/lisp/progmodes/eglot.el
+++ b/lisp/progmodes/eglot.el
@@ -282,7 +282,8 @@ automatically)."
      . ,(eglot-alternatives
          '(("solargraph" "socket" "--port" :autoport) "ruby-lsp")))
     (haskell-mode
-     . ("haskell-language-server-wrapper" "--lsp"))
+     . ,(eglot-alternatives
+         '(("haskell-language-server-wrapper" "--lsp") "static-ls")))
     (elm-mode . ("elm-language-server"))
     (mint-mode . ("mint" "ls"))
     ((kotlin-mode kotlin-ts-mode) . ("kotlin-language-server"))
@@ -308,7 +309,7 @@ automatically)."
     (racket-mode . ("racket" "-l" "racket-langserver"))
     ((latex-mode plain-tex-mode context-mode texinfo-mode bibtex-mode tex-mode)
      . ,(eglot-alternatives '("digestif" "texlab")))
-    (erlang-mode . ("erlang_ls" "--transport" "stdio"))
+    (erlang-mode . ("elp" "server"))
     (wat-mode . ("wat_server"))
     ((yaml-ts-mode yaml-mode) . ("yaml-language-server" "--stdio"))
     ((toml-ts-mode conf-toml-mode) . ("tombi" "lsp"))
@@ -1438,6 +1439,12 @@ PRESERVE-BUFFERS as in `eglot-shutdown', which see."
   (maphash (lambda (f s)
              (when (eq s server) (remhash f eglot--servers-by-xrefed-file)))
            eglot--servers-by-xrefed-file)
+  ;; Cleanup entries in 'flymake-list-only-diagnostics'
+  (setq flymake-list-only-diagnostics
+        (cl-delete-if
+         (lambda (x) (eq server
+                         (get-text-property 0 'eglot--server (car x))))
+         flymake-list-only-diagnostics))
   (cond ((eglot--shutdown-requested server)
          t)
         ((not (eglot--inhibit-autoreconnect server))
@@ -2024,21 +2031,25 @@ according to `eglot-advertise-cancellation'.")
                                 (timeout-fn nil timeout-fn-supplied-p)
                                 (timeout nil timeout-supplied-p)
                                 hint
-                                &aux moreargs
-                                id (buf (current-buffer)))
+                                &aux moreargs id
+                                (buf (current-buffer))
+                                (inflight eglot--inflight-async-requests))
   "Like `jsonrpc-async-request', but for Eglot LSP requests.
 SUCCESS-FN, ERROR-FN and TIMEOUT-FN run in buffer of call site.
 HINT argument is a symbol passed as DEFERRED to `jsonrpc-async-request'
 and also used as a hint of the request cancellation mechanism (see
 `eglot-advertise-cancellation')."
   (cl-labels
-      ((clearing-fn (fn)
+      ((wrapfn (fn)
          (lambda (&rest args)
            (eglot--when-live-buffer buf
-             (when (and
-                    fn (memq id (cl-getf eglot--inflight-async-requests hint)))
-               (apply fn args))
-             (cl-remf eglot--inflight-async-requests hint)))))
+             (cond (eglot-advertise-cancellation
+                    (when-let* ((tail (and fn (plist-member inflight hint))))
+                      (when (memq id (cadr tail))
+                        (apply fn args))
+                      (setf (cadr tail) (delete id (cadr tail)))))
+                   (t
+                    (apply fn args)))))))
     (eglot--cancel-inflight-async-requests (list hint))
     (when timeout-supplied-p
       (setq moreargs (nconc `(:timeout ,timeout) moreargs)))
@@ -2047,13 +2058,12 @@ and also used as a hint of the request cancellation mechanism (see
     (setq id
           (car (apply #'jsonrpc-async-request
                       server method params
-                      :success-fn (clearing-fn success-fn)
-                      :error-fn (clearing-fn error-fn)
-                      :timeout-fn (clearing-fn timeout-fn)
+                      :success-fn (wrapfn success-fn)
+                      :error-fn (wrapfn error-fn)
+                      :timeout-fn (wrapfn timeout-fn)
                       moreargs)))
     (when (and hint eglot-advertise-cancellation)
-      (push id
-            (plist-get eglot--inflight-async-requests hint)))
+      (push id (plist-get inflight hint)))
     id))
 
 (cl-defun eglot--delete-overlays (&optional (prop 'eglot--overlays))
@@ -3422,11 +3432,8 @@ object.  The originator of this \"push\" is usually either regular
       (with-current-buffer buffer
         (if (and version (/= version eglot--docver))
             (cl-return-from eglot--flymake-handle-push))
-        (setq
-         ;; if no explicit version received, assume it's current.
-         version eglot--docver
-         flymake-list-only-diagnostics
-         (assoc-delete-all path flymake-list-only-diagnostics))
+        ;; if no explicit version received, assume it's current.
+        (setq version eglot--docver)
         (funcall then diagnostics))
     (cl-loop
      for diag-spec across diagnostics
@@ -3437,12 +3444,13 @@ object.  The originator of this \"push\" is usually either regular
                  (flymake-make-diagnostic
                   path (cons line char) nil
                   (eglot--flymake-diag-type severity)
-                  (list source code message))))
+                  (list source code message)
+                  `((eglot-lsp-diag . ,diag-spec)))))
      into diags
      finally
-     (setq flymake-list-only-diagnostics
-           (assoc-delete-all path flymake-list-only-diagnostics))
-     (push (cons path diags) flymake-list-only-diagnostics))))
+     (setf (alist-get (propertize path 'eglot--server server)
+                      flymake-list-only-diagnostics nil nil #'equal)
+           diags))))
 
 (cl-defun eglot--flymake-pull (&aux (server (eglot--current-server-or-lose))
                                     (origin (current-buffer)))
@@ -3506,6 +3514,17 @@ MODE is like `eglot--flymake-report-1'."
      (pushed-outdated-p (and pushed-docver (< pushed-docver eglot--docver))))
   "Push previously collected diagnostics to `eglot--flymake-report-fn'.
 If KEEP, knowingly push a dummy do-nothing update."
+  ;; Maybe hack in diagnostics we previously may have saved in
+  ;; `flymake-list-only-diagnostics', pushed for this file before it was
+  ;; visited (github#1531).
+  (when-let* ((hack (and (<= eglot--docver 0)
+                         (null eglot--pushed-diagnostics)
+                         (cdr (assoc (buffer-file-name)
+                                     flymake-list-only-diagnostics)))))
+    (cl-loop
+     for x in hack
+     collect (alist-get 'eglot-lsp-diag (flymake-diagnostic-data x)) into res
+     finally (setq eglot--pushed-diagnostics `(,(vconcat res) ,eglot--docver))))
   (eglot--widening
    (if (and (null eglot--pulled-diagnostics) pushed-outdated-p)
        ;; Here, we don't have anything interesting to give to Flymake.
diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index c4fb6946aeb..f5c3dc3fbb2 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -1783,7 +1783,9 @@ and `eval-expression-print-level'.
   (funcall
    (syntax-propertize-rules
     (emacs-lisp-byte-code-comment-re
-     (1 (prog1 "< b" (elisp--byte-code-comment end (point))))))
+     (1 (prog1 "< b"
+          (goto-char (match-end 2))
+          (elisp--byte-code-comment end (point))))))
    start end))
 
 ;;;###autoload
diff --git a/lisp/progmodes/etags-regen.el b/lisp/progmodes/etags-regen.el
index b6adca8af7a..3d3ddc0521f 100644
--- a/lisp/progmodes/etags-regen.el
+++ b/lisp/progmodes/etags-regen.el
@@ -348,7 +348,7 @@ File extensions to generate the tags for."
 
 (defun etags-regen--build-program-options (ctags-p)
   (when (and etags-regen-regexp-alist ctags-p)
-    (user-error "etags-regen-regexp-alist is not supported with Ctags"))
+    (user-error "etags-regen-regexp-alist not supported with Ctags; to use this option, customize `etags-regen-program'"))
   (nconc
    (mapcan
     (lambda (group)
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 79cfb91caa9..f7532fce6b1 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -2114,8 +2114,14 @@ file name, add `tag-partial-file-name-match-p' to the list value.")
   :type 'boolean
   :version "28.1")
 
-;;;###autoload
-(defun etags--xref-backend () 'etags)
+;;;###autoload (defun etags--xref-backend ()
+;;;###autoload   (when (or tags-table-list tags-file-name)
+;;;###autoload     (load "etags")
+;;;###autoload     'etags))
+
+(defun etags--xref-backend ()
+  (when (or tags-table-list tags-file-name)
+    'etags))
 
 (cl-defmethod xref-backend-identifier-at-point ((_backend (eql 'etags)))
   (find-tag--default))
diff --git a/lisp/progmodes/make-mode.el b/lisp/progmodes/make-mode.el
index 8856856100e..e34eaba3150 100644
--- a/lisp/progmodes/make-mode.el
+++ b/lisp/progmodes/make-mode.el
@@ -331,7 +331,7 @@ not be enclosed in { } or ( )."
                                              &rest fl-keywords)
   `(;; Do macro assignments.  These get the "variable-name" face.
     (,makefile-macroassign-regex
-     (1 font-lock-variable-name-face)
+     (1 'font-lock-variable-name-face)
      ;; This is for after !=
      (2 'makefile-shell prepend t)
      ;; This is for after normal assignment
@@ -340,10 +340,10 @@ not be enclosed in { } or ( )."
     ;; Rule actions.
     ;; FIXME: When this spans multiple lines we need font-lock-multiline.
     (makefile-match-action
-     (1 font-lock-type-face nil t)
+     (1 'font-lock-type-face nil t)
      (2 'makefile-shell prepend)
      ;; Only makepp has builtin commands.
-     (3 font-lock-builtin-face prepend t))
+     (3 'font-lock-builtin-face prepend t))
 
     ;; Variable references even in targets/strings/comments.
     (,var 2 font-lock-variable-name-face prepend)
@@ -364,11 +364,11 @@ not be enclosed in { } or ( )."
                    (string-replace "-" "[_-]" (regexp-opt (cdr keywords) t))
                  (regexp-opt keywords t)))
               "\\>[ \t]*\\([^: \t\n#]*\\)")
-             (1 font-lock-keyword-face) (2 font-lock-variable-name-face))))
+             (1 'font-lock-keyword-face) (2 'font-lock-variable-name-face))))
 
     ,@(if negation
-          `((,negation (1 font-lock-negation-char-face prepend)
-                       (2 font-lock-negation-char-face prepend t))))
+          `((,negation (1 'font-lock-negation-char-face prepend)
+                       (2 'font-lock-negation-char-face prepend t))))
 
     ,@(if space
           '(;; Highlight lines that contain just whitespace.
@@ -436,9 +436,9 @@ not be enclosed in { } or ( )."
 
    ;; Colon modifier keywords.
    '("\\(:\\s *\\)\\(build_c\\(?:ache\\|heck\\)\\|env\\(?:ironment\\)?\\|foreach\\|signature\\|scanner\\|quickscan\\|smartscan\\)\\>\\([^:\n]*\\)"
-     (1 font-lock-type-face t)
-     (2 font-lock-keyword-face t)
-     (3 font-lock-variable-name-face t))
+     (1 'font-lock-type-face t)
+     (2 'font-lock-keyword-face t)
+     (3 'font-lock-variable-name-face t))
 
    ;; $(function ...) $((function ...)) ${...} ${{...}} $[...] $[[...]]
    '("[^$]\\$\\(?:((?\\|{{?\\|\\[\\[?\\)\\([-a-zA-Z0-9_.]+\\s \\)"
diff --git a/lisp/progmodes/project.el b/lisp/progmodes/project.el
index 997c876b1fa..9e5a8be5e13 100644
--- a/lisp/progmodes/project.el
+++ b/lisp/progmodes/project.el
@@ -84,6 +84,12 @@
 ;; This project type can also be used for non-VCS controlled
 ;; directories, see the variable `project-vc-extra-root-markers'.
 ;;
+;; Some of the methods on this backend cache their computations for time
+;; determined either by variable `project-vc-cache-timeout' or
+;; `project-vc-non-essential-cache-timeout', depending on whether the
+;; MAYBE-PROMPT argument to `project-current' is non-nil, or the value
+;; of `non-essential' when project methods are called.
+;;
 ;; Utils:
 ;;
 ;; `project-combine-directories' and `project-subtract-directories',
@@ -275,7 +281,8 @@ of the project instance object."
       (if pr
           (project-remember-project pr)
         (project--remove-from-project-list
-         directory "Project `%s' not found; removed from list")
+         (abbreviate-file-name directory)
+         "Project `%s' not found; removed from list")
         (setq pr (cons 'transient directory))))
     pr))
 
@@ -586,16 +593,74 @@ project backend implementation of `project-external-roots'.")
 
 See `project-vc-extra-root-markers' for the marker value format.")
 
-;; FIXME: Should perhaps use `vc--repo-*prop' functions
-;;        (after promoting those to public).  --spwhitton
+(defvar project-vc-cache-timeout '((file-remote-p . nil)
+                                   (always . 2))
+  "Number of seconds to cache a value in VC-aware project methods.
+It can be nil, a number, or an alist where
+the key is a predicate, and the value is a number.
+A predicate function should take a directory string and if it returns
+non-nil, the corresponding value will be used as the timeout.
+Set to nil to disable time-based expiration.")
+
+(defvar project-vc-non-essential-cache-timeout '((file-remote-p . nil)
+                                                 (always . 300))
+  "Number of seconds to cache non-essential information.
+The format of the value is same as `project-vc-cache-timeout', but while
+the former is intended for interactive commands, this variable uses
+higher numbers, intended for \"background\" things like
+`project-mode-line' indicators and `project-uniquify-dirname-transform'.
+It is used when `non-essential' is non-nil.")
+
+(defun project--get-cached (dir key)
+  (let ((cached (vc-file-getprop dir key))
+        (current-time (float-time)))
+    (when (and (numberp (cdr cached))
+               ;; Support package upgrade mid-session.
+               (let* ((project-vc-cache-timeout
+                       (if non-essential
+                           project-vc-non-essential-cache-timeout
+                         project-vc-cache-timeout))
+                      (timeout
+                       (cond
+                        ((numberp project-vc-cache-timeout)
+                         project-vc-cache-timeout)
+                        ((null project-vc-cache-timeout)
+                         nil)
+                        ((listp project-vc-cache-timeout)
+                         (cdr
+                          (seq-find (lambda (pair)
+                                      (and (functionp (car pair))
+                                           (funcall (car pair) dir)))
+                                    project-vc-cache-timeout)))
+                        (t nil))))
+                 (or (null timeout)
+                     (< (- current-time (cdr cached)) timeout))))
+      (car cached))))
+
+(defun project--set-cached (dir key value)
+  (vc-file-setprop dir key (cons value (float-time))))
+
+;; TODO: We can have our own, separate obarray.
+(defun project--clear-cache ()
+  (obarray-map
+   (lambda (sym)
+     (if (get sym 'project-vc)
+         (put sym 'project-vc nil)))
+   vc-file-prop-obarray))
+
 (defun project-try-vc (dir)
-  ;; FIXME: Learn to invalidate when the value changes:
-  ;; `project-vc-merge-submodules' or `project-vc-extra-root-markers'.
-  (or (vc-file-getprop dir 'project-vc)
-      ;; FIXME: Cache for a shorter time (bug#78545).
-      (let ((res (project-try-vc--search dir)))
-        (and res (vc-file-setprop dir 'project-vc res))
-        res)))
+  "Returns a project value corresponding to DIR from the VC-aware backend.
+
+The value is cached, and depending on whether MAYBE-PROMPT was non-nil
+in the `project-current' call, the timeout is determined by
+`project-vc-cache-timeout' or `project-vc-non-essential-cache-timeout'."
+  (let ((cached (project--get-cached dir 'project-vc)))
+    (if (eq cached 'none)
+        nil
+      (or cached
+          (let ((res (project-try-vc--search dir)))
+            (project--set-cached dir 'project-vc (or res 'none))
+            res)))))
 
 (defun project-try-vc--search (dir)
   (let* ((backend-markers
@@ -896,13 +961,24 @@ DIRS must contain directory names."
   (cl-set-difference files dirs :test #'file-in-directory-p))
 
 (defun project--value-in-dir (var dir)
+  (alist-get
+   var
+   (let ((cached (project--get-cached dir 'project-vc-dir-locals)))
+     (if (eq cached 'none)
+         nil
+       (or cached
+           (let ((res (project--read-dir-locals dir)))
+             (project--set-cached dir 'project-vc-dir-locals (or res 'none))
+             res))))
+   (symbol-value var)))
+
+(defun project--read-dir-locals (dir)
   (with-temp-buffer
     (setq default-directory (file-name-as-directory dir))
+    ;; Don't use `hack-local-variables-apply' to avoid setting modes.
     (let ((enable-local-variables :all))
       (hack-dir-local-variables))
-    ;; Don't use `hack-local-variables-apply' to avoid setting modes.
-    (alist-get var file-local-variables-alist
-               (symbol-value var))))
+    file-local-variables-alist))
 
 (cl-defmethod project-buffers ((project (head vc)))
   (let* ((root (expand-file-name (file-name-as-directory (project-root project))))
@@ -924,6 +1000,11 @@ DIRS must contain directory names."
     (nreverse bufs)))
 
 (cl-defmethod project-name ((project (head vc)))
+  "Returns the name of this VC-aware type PROJECT.
+
+The value is cached, and depending on whether `non-essential' is nil,
+the timeout is determined by `project-vc-cache-timeout' or
+`project-vc-non-essential-cache-timeout'."
   (or (project--value-in-dir 'project-vc-name (project-root project))
       (cl-call-next-method)))
 
@@ -2206,7 +2287,7 @@ result in `project-list-file'.  Announce the project's removal
 from the list using REPORT-MESSAGE, which is a format string
 passed to `message' as its first argument."
   (project--ensure-read-project-list)
-  (when-let* ((ent (assoc (abbreviate-file-name project-root) project--list)))
+  (when-let* ((ent (assoc project-root project--list)))
     (setq project--list (delq ent project--list))
     (message report-message project-root)
     (project--write-project-list)))
@@ -2385,6 +2466,7 @@ projects.
 Display a message at the end summarizing what was found.
 Return the number of detected projects."
   (interactive "DDirectory: \nP")
+  (project--clear-cache)
   (project--ensure-read-project-list)
   (let ((dirs (if recursive
                   (directory-files-recursively dir "" t)
@@ -2417,12 +2499,18 @@ PREDICATE can be a function with 1 argument which determines which
 projects should be deleted."
   (dolist (proj (project-known-project-roots))
     (when (and (funcall (or predicate #'identity) proj)
-               (not (file-exists-p proj)))
+               (condition-case-unless-debug nil
+                   (not (file-exists-p proj))
+                 (file-error
+                  (yes-or-no-p
+                   (format "Forget unreachable project `%s'? "
+                           proj)))))
       (project-forget-project proj))))
 
 (defun project-forget-zombie-projects (&optional interactive)
   "Forget all known projects that don't exist any more."
   (interactive (list t))
+  (project--clear-cache)
   (let ((pred (when interactive (alist-get 'interactively project-prune-zombie-projects))))
     (project--delete-zombie-projects pred)))
 
@@ -2435,6 +2523,7 @@ to remove those projects from the index.
 Display a message at the end summarizing what was forgotten.
 Return the number of forgotten projects."
   (interactive "DDirectory: \nP")
+  (project--clear-cache)
   (let ((count 0))
     (if recursive
         (dolist (proj (project-known-project-roots))
@@ -2624,7 +2713,8 @@ slash-separated components from `project-name' will be appended to
 the buffer's directory name when buffers from two different projects
 would otherwise have the same name."
   (if-let* ((proj (project-current nil dirname)))
-      (let ((root (project-root proj)))
+      (let ((root (project-root proj))
+            (non-essential t))
         (expand-file-name
          (file-name-concat
           (file-name-directory root)
@@ -2634,27 +2724,6 @@ would otherwise have the same name."
 
 ;;; Project mode-line
 
-(defvar project-name-cache-timeout 300
-  "Number of seconds to cache the project name.
-Used by `project-name-cached'.")
-
-(defun project-name-cached (dir)
-  "Return the cached project name for the directory DIR.
-Until it's cached, retrieve the project name using `project-current'
-and `project-name', then put the name to the cache for the time defined
-by the variable `project-name-cache-timeout'.  This function is useful
-for project indicators such as on the mode line."
-  (let ((cached (vc-file-getprop dir 'project-name))
-        (current-time (float-time)))
-    (if (and cached (< (- current-time (cdr cached))
-                       project-name-cache-timeout))
-        (let ((value (car cached)))
-          (if (eq value 'none) nil value))
-      (let ((res (when-let* ((project (project-current nil dir)))
-                   (project-name project))))
-        (vc-file-setprop dir 'project-name (cons (or res 'none) current-time))
-        res))))
-
 ;;;###autoload
 (defcustom project-mode-line nil
   "Whether to show current project name and Project menu on the mode line.
@@ -2691,7 +2760,9 @@ value is `non-remote', show the project name only for local files."
     ;; 'last-coding-system-used' when reading the project name
     ;; from .dir-locals.el also enables flyspell-mode (bug#66825).
     (when-let* ((last-coding-system-used last-coding-system-used)
-                (project-name (project-name-cached default-directory)))
+                (non-essential t)
+                (project (project-current))
+                (project-name (project-name project)))
       (concat
        " "
        (propertize
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index b6981c9156c..2a3035c95c5 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -3366,6 +3366,16 @@ from `python-shell-prompt-regexp',
             python-shell--prompt-calculated-output-regexp
             (funcall build-regexp output-prompts)))))
 
+(defun python-shell-get-project-name ()
+  "Return the project name for the current buffer.
+Use `project-name-cached' if available."
+  (when (featurep 'project)
+    (if (fboundp 'project-name-cached)
+        (project-name-cached default-directory)
+      (when-let* ((proj (project-current)))
+        (file-name-nondirectory
+         (directory-file-name (project-root proj)))))))
+
 (defun python-shell-get-process-name (dedicated)
   "Calculate the appropriate process name for inferior Python process.
 If DEDICATED is nil, this is simply `python-shell-buffer-name'.
@@ -3374,11 +3384,8 @@ name respectively the current project name."
   (pcase dedicated
     ('nil python-shell-buffer-name)
     ('project
-     (if-let* ((proj (and (featurep 'project)
-                          (project-current))))
-         (format "%s[%s]" python-shell-buffer-name (file-name-nondirectory
-                                                    (directory-file-name
-                                                     (project-root proj))))
+     (if-let* ((proj-name (python-shell-get-project-name)))
+         (format "%s[%s]" python-shell-buffer-name proj-name)
        python-shell-buffer-name))
     (_ (format "%s[%s]" python-shell-buffer-name (buffer-name)))))
 
@@ -3816,16 +3823,6 @@ variable.
   (compilation-shell-minor-mode 1)
   (python-pdbtrack-setup-tracking))
 
-(defvar-local python-shell--process-cache)
-(defvar-local python-shell--process-cache-valid)
-
-(defun python-shell--invalidate-process-cache ()
-  "Invalidate process cache."
-  (dolist (buffer (buffer-list))
-    (with-current-buffer buffer
-      (setq python-shell--process-cache nil
-            python-shell--process-cache-valid nil))))
-
 (defun python-shell-make-comint (cmd proc-name &optional show internal)
   "Create a Python shell comint buffer.
 CMD is the Python command to be executed and PROC-NAME is the
@@ -3842,7 +3839,6 @@ killed."
       (let* ((proc-buffer-name
               (format (if (not internal) "*%s*" " *%s*") proc-name)))
         (when (not (comint-check-proc proc-buffer-name))
-          (python-shell--invalidate-process-cache)
           (let* ((cmdlist (split-string-and-unquote cmd))
                  (interpreter (car cmdlist))
                  (args (cdr cmdlist))
@@ -3966,15 +3962,7 @@ If current buffer is in `inferior-python-mode', return it."
 
 (defun python-shell-get-process ()
   "Return inferior Python process for current buffer."
-  (unless (and python-shell--process-cache-valid
-               (or (not python-shell--process-cache)
-                   (and (process-live-p python-shell--process-cache)
-                        (buffer-live-p
-                         (process-buffer python-shell--process-cache)))))
-    (setq python-shell--process-cache
-          (get-buffer-process (python-shell-get-buffer))
-          python-shell--process-cache-valid t))
-  python-shell--process-cache)
+  (get-buffer-process (python-shell-get-buffer)))
 
 (defun python-shell-get-process-or-error (&optional interactivep)
   "Return inferior Python process for current buffer or signal error.
@@ -5854,7 +5842,7 @@ Set to nil by `python-eldoc-function' if
 
 (defcustom python-eldoc-function-timeout 1
   "Timeout for `python-eldoc-function' in seconds."
-  :type 'integer
+  :type 'number
   :version "25.1")
 
 (defcustom python-eldoc-function-timeout-permanent t
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index 84a3fa4dfba..1e51b23eaff 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -247,11 +247,9 @@ generic functions.")
 
 ;;;###autoload
 (defun xref-find-backend ()
-  (or
-   (run-hook-with-args-until-success 'xref-backend-functions)
-   (user-error "No Xref backend available")))
+  (run-hook-with-args-until-success 'xref-backend-functions))
 
-(cl-defgeneric xref-backend-definitions (backend identifier)
+(cl-defgeneric xref-backend-definitions (_backend _identifier)
   "Find definitions of IDENTIFIER.
 
 The result must be a list of xref objects.  If IDENTIFIER
@@ -264,7 +262,8 @@ IDENTIFIER can be any string returned by
 `xref-backend-identifier-at-point', or from the table returned by
 `xref-backend-identifier-completion-table'.
 
-To create an xref object, call `xref-make'.")
+To create an xref object, call `xref-make'."
+  (xref--no-backend-available))
 
 (cl-defgeneric xref-backend-references (_backend identifier)
   "Find references of IDENTIFIER.
@@ -285,12 +284,13 @@ The default implementation uses `xref-references-in-directory'."
        (xref--project-root pr)
        (project-external-roots pr))))))
 
-(cl-defgeneric xref-backend-apropos (backend pattern)
+(cl-defgeneric xref-backend-apropos (_backend _pattern)
   "Find all symbols that match PATTERN string.
 The second argument has the same meaning as in `apropos'.
 
 If BACKEND is implemented in Lisp, it can use
-`xref-apropos-regexp' to convert the pattern to regexp.")
+`xref-apropos-regexp' to convert the pattern to regexp."
+  (xref--no-backend-available))
 
 (cl-defgeneric xref-backend-identifier-at-point (_backend)
   "Return the relevant identifier at point.
@@ -306,8 +306,9 @@ recognize and then delegate the work to an external process."
   (let ((thing (thing-at-point 'symbol)))
     (and thing (substring-no-properties thing))))
 
-(cl-defgeneric xref-backend-identifier-completion-table (backend)
-  "Return the completion table for identifiers.")
+(cl-defgeneric xref-backend-identifier-completion-table (_backend)
+  "Return the completion table for identifiers."
+  nil)
 
 (cl-defgeneric xref-backend-identifier-completion-ignore-case (_backend)
   "Return t if case is not significant in identifier completion."
@@ -329,6 +330,10 @@ KEY extracts the key from an element."
     (cl-loop for key being hash-keys of table using (hash-values value)
              collect (cons key (nreverse value)))))
 
+(defun xref--no-backend-available ()
+  (user-error
+   "No Xref backend.  Try `M-x eglot', `M-x visit-tags-table', or `M-x etags-regen-mode'."))
+
 (defun xref--insert-propertized (props &rest strings)
   "Insert STRINGS with text properties PROPS."
   (let ((start (point)))