bug#73436: eglot-1.17 fails to run in emacs 29.4

bug#73436: eglot-1.17 fails to run in emacs 29.4

[Dov Grobgeld]

Running the latest version of eglot, version 1.17, installed by
package-list-packages, on emacs 29.4 fails.

Here's what I did:

$ cd /tmp/eglot-1.17
$ emacs -Q -nw eglot.el

and then the interactive commands

M-x eval-buffer
C-x C-f hello.c
C-: (setq debug-on-error t)
M-x eglot

This resulted in an error. Here is the stack trace:

Debugger entered--Lisp error: (invalid-slot-name "#<eglot-lsp-server
eglot-lsp-server-93e4e78>" :events-buffer-config)
  signal(invalid-slot-name ("#<eglot-lsp-server
eglot-lsp-server-93e4e78>" :events-buffer-config))
  slot-missing(#<eglot-lsp-server eglot-lsp-server-93e4e78>
:events-buffer-config oset (:size 2000000 :format full))
  #f(compiled-function (obj slots) "Set slots of OBJ with SLOTS which
is a list of name/value pairs.\nCalled from the constructor routine."
#<bytecode 0x4590eddf9051ddd>)(#<eglot-lsp-server
eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  apply(#f(compiled-function (obj slots) "Set slots of OBJ with SLOTS
which is a list of name/value pairs.\nCalled from the constructor
routine." #<bytecode 0x4590eddf9051ddd>) #<eglot-lsp-server
eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  shared-initialize(#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  #f(compiled-function (this &optional args) "Construct the new object
THIS based on ARGS.\nARGS is a property list where odd numbered
elements are tags, and\neven numbered elements are the values to store
in the tagged slot.\nIf you overload the `initialize-instance', there
you will need to\ncall `shared-initialize' yourself, or you can call
`call-next-method'\nto have this constructor called automatically.  If
these steps are\nnot taken, then new objects of your class will not
have their values\ndynamically set from ARGS." #<bytecode
-0x1f60eebd0e85d7f7>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  apply(#f(compiled-function (this &optional args) "Construct the new
object THIS based on ARGS.\nARGS is a property list where odd numbered
elements are tags, and\neven numbered elements are the values to store
in the tagged slot.\nIf you overload the `initialize-instance', there
you will need to\ncall `shared-initialize' yourself, or you can call
`call-next-method'\nto have this constructor called automatically.  If
these steps are\nnot taken, then new objects of your class will not
have their values\ndynamically set from ARGS." #<bytecode
-0x1f60eebd0e85d7f7>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t))))))
  #f(compiled-function (&rest args) #<bytecode -0x7469b45b80fef61>)()
  #f(compiled-function (cl--cnm conn slots) #<bytecode
0x18a7bfd9b312194c>)(#f(compiled-function (&rest args) #<bytecode
-0x7469b45b80fef61>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  apply(#f(compiled-function (cl--cnm conn slots) #<bytecode
0x18a7bfd9b312194c>) #f(compiled-function (&rest args) #<bytecode
-0x7469b45b80fef61>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t))))))
  #f(compiled-function (conn slots) #<bytecode
0x164956dec53e81bc>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  apply(#f(compiled-function (conn slots) #<bytecode
0x164956dec53e81bc>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t))))))
  #f(compiled-function (&rest args) #<bytecode
-0xb77c4438ff27908>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  apply(#f(compiled-function (&rest args) #<bytecode
-0xb77c4438ff27908>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  initialize-instance(#<eglot-lsp-server eglot-lsp-server-93e4e78>
(:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  #f(compiled-function (class &rest slots) "Default constructor for
CLASS `eieio-default-superclass'.\nSLOTS are the initialization slots
used by `initialize-instance'.\nThis static method is called when an
object is constructed.\nIt allocates the vector used to represent an
EIEIO object, and then\ncalls `initialize-instance' on that object."
#<bytecode -0x982733269180e59>)(eglot-lsp-server :name "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
(:size 2000000 :format full) :notification-dispatcher (closure ((fn .
eglot-handle-notification)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :on-shutdown eglot--on-shutdown
:process (closure ((contact "/usr/bin/clangd") (server-info)
(readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
c++-t...") tramp-ssh-controlmaster-options
tramp-use-ssh-controlmaster-options) nil (let ((default-directory
default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t))))
  apply(#f(compiled-function (class &rest slots) "Default constructor
for CLASS `eieio-default-superclass'.\nSLOTS are the initialization
slots used by `initialize-instance'.\nThis static method is called
when an object is constructed.\nIt allocates the vector used to
represent an EIEIO object, and then\ncalls `initialize-instance' on
that object." #<bytecode -0x982733269180e59>) eglot-lsp-server (:name
"EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
:events-buffer-config (:size 2000000 :format full)
:notification-dispatcher (closure ((fn . eglot-handle-notification))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :request-dispatcher (closure ((fn
. eglot-handle-request)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
"/usr/bin/clangd") (server-info) (readable-name . "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
nil (let ((default-directory default-directory)
(tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  make-instance(eglot-lsp-server :name "EGLOT (eglot-1.17/(c-mode
c-ts-mode c++-mode c++-t..." :events-buffer-config (:size 2000000
:format full) :notification-dispatcher (closure ((fn .
eglot-handle-notification)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :on-shutdown eglot--on-shutdown
:process (closure ((contact "/usr/bin/clangd") (server-info)
(readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
c++-t...") tramp-ssh-controlmaster-options
tramp-use-ssh-controlmaster-options) nil (let ((default-directory
default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t))))
  apply(make-instance eglot-lsp-server :name "EGLOT
(eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
(:size 2000000 :format full) :notification-dispatcher (closure ((fn .
eglot-handle-notification)) (server method params) (let
((eglot--cached-server server)) (apply fn server method (append params
nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
(server method params) (let ((eglot--cached-server server)) (apply fn
server method (append params nil)))) :on-shutdown eglot--on-shutdown
(:process (closure ((contact "/usr/bin/clangd") (server-info)
(readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
c++-t...") tramp-ssh-controlmaster-options
tramp-use-ssh-controlmaster-options) nil (let ((default-directory
default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
(tramp-ssh-controlmaster-options "-o ControlMaster=no -o
ControlPath=none")) (make-process :name readable-name :command (setq
server-info (eglot--cmd contact)) :connection-type 'pipe :coding
'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
stderr*" readable-name)) :file-handler t)))))
  (let* ((default-directory (project-root project)) (nickname
(project-name project)) (readable-name (format "EGLOT (%s/%s)"
nickname managed-modes)) server-info (contact (if (functionp contact)
(funcall contact) contact)) (initargs (cond ((keywordp (car contact))
contact) ((integerp (car (cdr contact))) (setq server-info (list
(format "%s:%s" ... ...))) (list ':process #'(lambda nil ...))) ((and
(stringp (car contact)) (cl-find-if #'... contact)) (setq server-info
(list "<inferior process>")) (list ':process
(jsonrpc-autoport-bootstrap readable-name contact :connect-args
'...))) ((stringp (car contact)) (let* ((probe ...) (more-initargs
...) (contact ...)) (cons ':process (cons ... more-initargs))))))
(spread #'(lambda (fn) #'(lambda (server method params) (let ...
...)))) (server (apply #'make-instance class :name readable-name
:events-buffer-config eglot-events-buffer-config
:notification-dispatcher (funcall spread #'eglot-handle-notification)
:request-dispatcher (funcall spread #'eglot-handle-request)
:on-shutdown #'eglot--on-shutdown initargs)) (canceled nil) (tag
(make-symbol "connected-catch-tag"))) (if server-info (progn
(jsonrpc--debug server "Running language server: %s" (string-join
server-info " ")))) (let* ((v server)) (\(setf\
eglot--saved-initargs\) initargs v)) (let* ((v server)) (\(setf\
eglot--project\) project v)) (let* ((v server)) (\(setf\
eglot--project-nickname\) nickname v)) (let* ((v server)) (\(setf\
eglot--languages\) (let* ((--cl-var-- managed-modes) (m nil)
(--cl-var-- language-ids) (l nil) (--cl-var-- nil)) (while (and (consp
--cl-var--) (progn (setq m ...) (consp --cl-var--))) (setq l (car
--cl-var--)) (setq --cl-var-- (cons (cons m l) --cl-var--)) (setq
--cl-var-- (cdr --cl-var--)) (setq --cl-var-- (cdr --cl-var--)))
(nreverse --cl-var--)) v)) (run-hook-with-args
'eglot-server-initialized-hook server) (unwind-protect (condition-case
_quit (let ((retval (catch tag (jsonrpc-async-request server
:initialize ... :success-fn ... :timeout eglot-connect-timeout
:error-fn ... :timeout-fn ...) (cond ... ...)))) (cond ((consp retval)
(let* (...) (if ... ... ...))) ((null retval) (let nil (eglot--message
"Waiting in background for server `%s'" ...) nil)) (t (let nil
server)))) (quit (jsonrpc-shutdown server) (setq canceled 'quit)))
(setq tag nil)))
  eglot--connect((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode)
(transient . "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd")
("c" "c" "c++" "c++" "objc"))
  eglot((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode) (transient .
"/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd") ("c" "c"
"c++" "c++" "objc") t)
  funcall-interactively(eglot (c-mode c-ts-mode c++-mode c++-ts-mode
objc-mode) (transient . "/tmp/eglot-1.17/") eglot-lsp-server
("/usr/bin/clangd") ("c" "c" "c++" "c++" "objc") t)
  command-execute(eglot record)
  execute-extended-command(nil "eglot" "eglot")
  funcall-interactively(execute-extended-command nil "eglot" "eglot")
  command-execute(execute-extended-command)

bug#73436: eglot-1.17 fails to run in emacs 29.4

[Eli Zaretskii]

> From: Dov Grobgeld <dov.grobgeld@gmail.com>
> Date: Mon, 23 Sep 2024 11:58:03 +0300
> 
> Running the latest version of eglot, version 1.17, installed by
> package-list-packages, on emacs 29.4 fails.

Adding João.

> Here's what I did:
> 
> $ cd /tmp/eglot-1.17
> $ emacs -Q -nw eglot.el
> 
> and then the interactive commands
> 
> M-x eval-buffer
> C-x C-f hello.c
> C-: (setq debug-on-error t)
> M-x eglot
> 
> This resulted in an error. Here is the stack trace:
> 
> Debugger entered--Lisp error: (invalid-slot-name "#<eglot-lsp-server
> eglot-lsp-server-93e4e78>" :events-buffer-config)
>   signal(invalid-slot-name ("#<eglot-lsp-server
> eglot-lsp-server-93e4e78>" :events-buffer-config))
>   slot-missing(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> :events-buffer-config oset (:size 2000000 :format full))
>   #f(compiled-function (obj slots) "Set slots of OBJ with SLOTS which
> is a list of name/value pairs.\nCalled from the constructor routine."
> #<bytecode 0x4590eddf9051ddd>)(#<eglot-lsp-server
> eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
> c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   apply(#f(compiled-function (obj slots) "Set slots of OBJ with SLOTS
> which is a list of name/value pairs.\nCalled from the constructor
> routine." #<bytecode 0x4590eddf9051ddd>) #<eglot-lsp-server
> eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
> c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   shared-initialize(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   #f(compiled-function (this &optional args) "Construct the new object
> THIS based on ARGS.\nARGS is a property list where odd numbered
> elements are tags, and\neven numbered elements are the values to store
> in the tagged slot.\nIf you overload the `initialize-instance', there
> you will need to\ncall `shared-initialize' yourself, or you can call
> `call-next-method'\nto have this constructor called automatically.  If
> these steps are\nnot taken, then new objects of your class will not
> have their values\ndynamically set from ARGS." #<bytecode
> -0x1f60eebd0e85d7f7>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   apply(#f(compiled-function (this &optional args) "Construct the new
> object THIS based on ARGS.\nARGS is a property list where odd numbered
> elements are tags, and\neven numbered elements are the values to store
> in the tagged slot.\nIf you overload the `initialize-instance', there
> you will need to\ncall `shared-initialize' yourself, or you can call
> `call-next-method'\nto have this constructor called automatically.  If
> these steps are\nnot taken, then new objects of your class will not
> have their values\ndynamically set from ARGS." #<bytecode
> -0x1f60eebd0e85d7f7>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t))))))
>   #f(compiled-function (&rest args) #<bytecode -0x7469b45b80fef61>)()
>   #f(compiled-function (cl--cnm conn slots) #<bytecode
> 0x18a7bfd9b312194c>)(#f(compiled-function (&rest args) #<bytecode
> -0x7469b45b80fef61>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   apply(#f(compiled-function (cl--cnm conn slots) #<bytecode
> 0x18a7bfd9b312194c>) #f(compiled-function (&rest args) #<bytecode
> -0x7469b45b80fef61>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t))))))
>   #f(compiled-function (conn slots) #<bytecode
> 0x164956dec53e81bc>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   apply(#f(compiled-function (conn slots) #<bytecode
> 0x164956dec53e81bc>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t))))))
>   #f(compiled-function (&rest args) #<bytecode
> -0xb77c4438ff27908>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   apply(#f(compiled-function (&rest args) #<bytecode
> -0xb77c4438ff27908>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   initialize-instance(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   #f(compiled-function (class &rest slots) "Default constructor for
> CLASS `eieio-default-superclass'.\nSLOTS are the initialization slots
> used by `initialize-instance'.\nThis static method is called when an
> object is constructed.\nIt allocates the vector used to represent an
> EIEIO object, and then\ncalls `initialize-instance' on that object."
> #<bytecode -0x982733269180e59>)(eglot-lsp-server :name "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
> (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
> eglot-handle-notification)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :on-shutdown eglot--on-shutdown
> :process (closure ((contact "/usr/bin/clangd") (server-info)
> (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> c++-t...") tramp-ssh-controlmaster-options
> tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t))))
>   apply(#f(compiled-function (class &rest slots) "Default constructor
> for CLASS `eieio-default-superclass'.\nSLOTS are the initialization
> slots used by `initialize-instance'.\nThis static method is called
> when an object is constructed.\nIt allocates the vector used to
> represent an EIEIO object, and then\ncalls `initialize-instance' on
> that object." #<bytecode -0x982733269180e59>) eglot-lsp-server (:name
> "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> :events-buffer-config (:size 2000000 :format full)
> :notification-dispatcher (closure ((fn . eglot-handle-notification))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :request-dispatcher (closure ((fn
> . eglot-handle-request)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> nil (let ((default-directory default-directory)
> (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   make-instance(eglot-lsp-server :name "EGLOT (eglot-1.17/(c-mode
> c-ts-mode c++-mode c++-t..." :events-buffer-config (:size 2000000
> :format full) :notification-dispatcher (closure ((fn .
> eglot-handle-notification)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :on-shutdown eglot--on-shutdown
> :process (closure ((contact "/usr/bin/clangd") (server-info)
> (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> c++-t...") tramp-ssh-controlmaster-options
> tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t))))
>   apply(make-instance eglot-lsp-server :name "EGLOT
> (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
> (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
> eglot-handle-notification)) (server method params) (let
> ((eglot--cached-server server)) (apply fn server method (append params
> nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> (server method params) (let ((eglot--cached-server server)) (apply fn
> server method (append params nil)))) :on-shutdown eglot--on-shutdown
> (:process (closure ((contact "/usr/bin/clangd") (server-info)
> (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> c++-t...") tramp-ssh-controlmaster-options
> tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> ControlPath=none")) (make-process :name readable-name :command (setq
> server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> stderr*" readable-name)) :file-handler t)))))
>   (let* ((default-directory (project-root project)) (nickname
> (project-name project)) (readable-name (format "EGLOT (%s/%s)"
> nickname managed-modes)) server-info (contact (if (functionp contact)
> (funcall contact) contact)) (initargs (cond ((keywordp (car contact))
> contact) ((integerp (car (cdr contact))) (setq server-info (list
> (format "%s:%s" ... ...))) (list ':process #'(lambda nil ...))) ((and
> (stringp (car contact)) (cl-find-if #'... contact)) (setq server-info
> (list "<inferior process>")) (list ':process
> (jsonrpc-autoport-bootstrap readable-name contact :connect-args
> '...))) ((stringp (car contact)) (let* ((probe ...) (more-initargs
> ...) (contact ...)) (cons ':process (cons ... more-initargs))))))
> (spread #'(lambda (fn) #'(lambda (server method params) (let ...
> ...)))) (server (apply #'make-instance class :name readable-name
> :events-buffer-config eglot-events-buffer-config
> :notification-dispatcher (funcall spread #'eglot-handle-notification)
> :request-dispatcher (funcall spread #'eglot-handle-request)
> :on-shutdown #'eglot--on-shutdown initargs)) (canceled nil) (tag
> (make-symbol "connected-catch-tag"))) (if server-info (progn
> (jsonrpc--debug server "Running language server: %s" (string-join
> server-info " ")))) (let* ((v server)) (\(setf\
> eglot--saved-initargs\) initargs v)) (let* ((v server)) (\(setf\
> eglot--project\) project v)) (let* ((v server)) (\(setf\
> eglot--project-nickname\) nickname v)) (let* ((v server)) (\(setf\
> eglot--languages\) (let* ((--cl-var-- managed-modes) (m nil)
> (--cl-var-- language-ids) (l nil) (--cl-var-- nil)) (while (and (consp
> --cl-var--) (progn (setq m ...) (consp --cl-var--))) (setq l (car
> --cl-var--)) (setq --cl-var-- (cons (cons m l) --cl-var--)) (setq
> --cl-var-- (cdr --cl-var--)) (setq --cl-var-- (cdr --cl-var--)))
> (nreverse --cl-var--)) v)) (run-hook-with-args
> 'eglot-server-initialized-hook server) (unwind-protect (condition-case
> _quit (let ((retval (catch tag (jsonrpc-async-request server
> :initialize ... :success-fn ... :timeout eglot-connect-timeout
> :error-fn ... :timeout-fn ...) (cond ... ...)))) (cond ((consp retval)
> (let* (...) (if ... ... ...))) ((null retval) (let nil (eglot--message
> "Waiting in background for server `%s'" ...) nil)) (t (let nil
> server)))) (quit (jsonrpc-shutdown server) (setq canceled 'quit)))
> (setq tag nil)))
>   eglot--connect((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode)
> (transient . "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd")
> ("c" "c" "c++" "c++" "objc"))
>   eglot((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode) (transient .
> "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd") ("c" "c"
> "c++" "c++" "objc") t)
>   funcall-interactively(eglot (c-mode c-ts-mode c++-mode c++-ts-mode
> objc-mode) (transient . "/tmp/eglot-1.17/") eglot-lsp-server
> ("/usr/bin/clangd") ("c" "c" "c++" "c++" "objc") t)
>   command-execute(eglot record)
>   execute-extended-command(nil "eglot" "eglot")
>   funcall-interactively(execute-extended-command nil "eglot" "eglot")
>   command-execute(execute-extended-command)
> 
> 
> 
> 

bug#73436: eglot-1.17 fails to run in emacs 29.4

[João Távora]

[-- Attachment #1: Type: text/plain, Size: 27460 bytes --]

Dov, I don't know where you may have obtained the idea that this
eval-buffer activation method is supported. It isn't.

Eglot has dependencies, so either use package.el facilities to ensure that
they are installed and activated or use Emacs master. IIRC, in Emacs 29.4
one can use M-x eglot-upgrade-eglot to get and activate the latest version
from GNU Elpa (or GNU-devel Elpa) correctly. Other methods are not
supported.


On Mon, Sep 23, 2024, 12:58 Eli Zaretskii <eliz@gnu.org> wrote:

> > From: Dov Grobgeld <dov.grobgeld@gmail.com>
> > Date: Mon, 23 Sep 2024 11:58:03 +0300
> >
> > Running the latest version of eglot, version 1.17, installed by
> > package-list-packages, on emacs 29.4 fails.
>
> Adding João.
>
> > Here's what I did:
> >
> > $ cd /tmp/eglot-1.17
> > $ emacs -Q -nw eglot.el
> >
> > and then the interactive commands
> >
> > M-x eval-buffer
> > C-x C-f hello.c
> > C-: (setq debug-on-error t)
> > M-x eglot
> >
> > This resulted in an error. Here is the stack trace:
> >
> > Debugger entered--Lisp error: (invalid-slot-name "#<eglot-lsp-server
> > eglot-lsp-server-93e4e78>" :events-buffer-config)
> >   signal(invalid-slot-name ("#<eglot-lsp-server
> > eglot-lsp-server-93e4e78>" :events-buffer-config))
> >   slot-missing(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > :events-buffer-config oset (:size 2000000 :format full))
> >   #f(compiled-function (obj slots) "Set slots of OBJ with SLOTS which
> > is a list of name/value pairs.\nCalled from the constructor routine."
> > #<bytecode 0x4590eddf9051ddd>)(#<eglot-lsp-server
> > eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
> > c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   apply(#f(compiled-function (obj slots) "Set slots of OBJ with SLOTS
> > which is a list of name/value pairs.\nCalled from the constructor
> > routine." #<bytecode 0x4590eddf9051ddd>) #<eglot-lsp-server
> > eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
> > c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   shared-initialize(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   #f(compiled-function (this &optional args) "Construct the new object
> > THIS based on ARGS.\nARGS is a property list where odd numbered
> > elements are tags, and\neven numbered elements are the values to store
> > in the tagged slot.\nIf you overload the `initialize-instance', there
> > you will need to\ncall `shared-initialize' yourself, or you can call
> > `call-next-method'\nto have this constructor called automatically.  If
> > these steps are\nnot taken, then new objects of your class will not
> > have their values\ndynamically set from ARGS." #<bytecode
> > -0x1f60eebd0e85d7f7>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   apply(#f(compiled-function (this &optional args) "Construct the new
> > object THIS based on ARGS.\nARGS is a property list where odd numbered
> > elements are tags, and\neven numbered elements are the values to store
> > in the tagged slot.\nIf you overload the `initialize-instance', there
> > you will need to\ncall `shared-initialize' yourself, or you can call
> > `call-next-method'\nto have this constructor called automatically.  If
> > these steps are\nnot taken, then new objects of your class will not
> > have their values\ndynamically set from ARGS." #<bytecode
> > -0x1f60eebd0e85d7f7>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t))))))
> >   #f(compiled-function (&rest args) #<bytecode -0x7469b45b80fef61>)()
> >   #f(compiled-function (cl--cnm conn slots) #<bytecode
> > 0x18a7bfd9b312194c>)(#f(compiled-function (&rest args) #<bytecode
> > -0x7469b45b80fef61>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   apply(#f(compiled-function (cl--cnm conn slots) #<bytecode
> > 0x18a7bfd9b312194c>) #f(compiled-function (&rest args) #<bytecode
> > -0x7469b45b80fef61>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t))))))
> >   #f(compiled-function (conn slots) #<bytecode
> > 0x164956dec53e81bc>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   apply(#f(compiled-function (conn slots) #<bytecode
> > 0x164956dec53e81bc>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t))))))
> >   #f(compiled-function (&rest args) #<bytecode
> > -0xb77c4438ff27908>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   apply(#f(compiled-function (&rest args) #<bytecode
> > -0xb77c4438ff27908>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   initialize-instance(#<eglot-lsp-server eglot-lsp-server-93e4e78>
> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   #f(compiled-function (class &rest slots) "Default constructor for
> > CLASS `eieio-default-superclass'.\nSLOTS are the initialization slots
> > used by `initialize-instance'.\nThis static method is called when an
> > object is constructed.\nIt allocates the vector used to represent an
> > EIEIO object, and then\ncalls `initialize-instance' on that object."
> > #<bytecode -0x982733269180e59>)(eglot-lsp-server :name "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
> > (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
> > eglot-handle-notification)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
> > :process (closure ((contact "/usr/bin/clangd") (server-info)
> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> > c++-t...") tramp-ssh-controlmaster-options
> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t))))
> >   apply(#f(compiled-function (class &rest slots) "Default constructor
> > for CLASS `eieio-default-superclass'.\nSLOTS are the initialization
> > slots used by `initialize-instance'.\nThis static method is called
> > when an object is constructed.\nIt allocates the vector used to
> > represent an EIEIO object, and then\ncalls `initialize-instance' on
> > that object." #<bytecode -0x982733269180e59>) eglot-lsp-server (:name
> > "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
> > :events-buffer-config (:size 2000000 :format full)
> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :request-dispatcher (closure ((fn
> > . eglot-handle-request)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
> > nil (let ((default-directory default-directory)
> > (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   make-instance(eglot-lsp-server :name "EGLOT (eglot-1.17/(c-mode
> > c-ts-mode c++-mode c++-t..." :events-buffer-config (:size 2000000
> > :format full) :notification-dispatcher (closure ((fn .
> > eglot-handle-notification)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
> > :process (closure ((contact "/usr/bin/clangd") (server-info)
> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> > c++-t...") tramp-ssh-controlmaster-options
> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t))))
> >   apply(make-instance eglot-lsp-server :name "EGLOT
> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
> > (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
> > eglot-handle-notification)) (server method params) (let
> > ((eglot--cached-server server)) (apply fn server method (append params
> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
> > (server method params) (let ((eglot--cached-server server)) (apply fn
> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
> > (:process (closure ((contact "/usr/bin/clangd") (server-info)
> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
> > c++-t...") tramp-ssh-controlmaster-options
> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
> > ControlPath=none")) (make-process :name readable-name :command (setq
> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
> > stderr*" readable-name)) :file-handler t)))))
> >   (let* ((default-directory (project-root project)) (nickname
> > (project-name project)) (readable-name (format "EGLOT (%s/%s)"
> > nickname managed-modes)) server-info (contact (if (functionp contact)
> > (funcall contact) contact)) (initargs (cond ((keywordp (car contact))
> > contact) ((integerp (car (cdr contact))) (setq server-info (list
> > (format "%s:%s" ... ...))) (list ':process #'(lambda nil ...))) ((and
> > (stringp (car contact)) (cl-find-if #'... contact)) (setq server-info
> > (list "<inferior process>")) (list ':process
> > (jsonrpc-autoport-bootstrap readable-name contact :connect-args
> > '...))) ((stringp (car contact)) (let* ((probe ...) (more-initargs
> > ...) (contact ...)) (cons ':process (cons ... more-initargs))))))
> > (spread #'(lambda (fn) #'(lambda (server method params) (let ...
> > ...)))) (server (apply #'make-instance class :name readable-name
> > :events-buffer-config eglot-events-buffer-config
> > :notification-dispatcher (funcall spread #'eglot-handle-notification)
> > :request-dispatcher (funcall spread #'eglot-handle-request)
> > :on-shutdown #'eglot--on-shutdown initargs)) (canceled nil) (tag
> > (make-symbol "connected-catch-tag"))) (if server-info (progn
> > (jsonrpc--debug server "Running language server: %s" (string-join
> > server-info " ")))) (let* ((v server)) (\(setf\
> > eglot--saved-initargs\) initargs v)) (let* ((v server)) (\(setf\
> > eglot--project\) project v)) (let* ((v server)) (\(setf\
> > eglot--project-nickname\) nickname v)) (let* ((v server)) (\(setf\
> > eglot--languages\) (let* ((--cl-var-- managed-modes) (m nil)
> > (--cl-var-- language-ids) (l nil) (--cl-var-- nil)) (while (and (consp
> > --cl-var--) (progn (setq m ...) (consp --cl-var--))) (setq l (car
> > --cl-var--)) (setq --cl-var-- (cons (cons m l) --cl-var--)) (setq
> > --cl-var-- (cdr --cl-var--)) (setq --cl-var-- (cdr --cl-var--)))
> > (nreverse --cl-var--)) v)) (run-hook-with-args
> > 'eglot-server-initialized-hook server) (unwind-protect (condition-case
> > _quit (let ((retval (catch tag (jsonrpc-async-request server
> > :initialize ... :success-fn ... :timeout eglot-connect-timeout
> > :error-fn ... :timeout-fn ...) (cond ... ...)))) (cond ((consp retval)
> > (let* (...) (if ... ... ...))) ((null retval) (let nil (eglot--message
> > "Waiting in background for server `%s'" ...) nil)) (t (let nil
> > server)))) (quit (jsonrpc-shutdown server) (setq canceled 'quit)))
> > (setq tag nil)))
> >   eglot--connect((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode)
> > (transient . "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd")
> > ("c" "c" "c++" "c++" "objc"))
> >   eglot((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode) (transient .
> > "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd") ("c" "c"
> > "c++" "c++" "objc") t)
> >   funcall-interactively(eglot (c-mode c-ts-mode c++-mode c++-ts-mode
> > objc-mode) (transient . "/tmp/eglot-1.17/") eglot-lsp-server
> > ("/usr/bin/clangd") ("c" "c" "c++" "c++" "objc") t)
> >   command-execute(eglot record)
> >   execute-extended-command(nil "eglot" "eglot")
> >   funcall-interactively(execute-extended-command nil "eglot" "eglot")
> >   command-execute(execute-extended-command)
> >
> >
> >
> >
>

[-- Attachment #2: Type: text/html, Size: 31812 bytes --]

bug#73436: eglot-1.17 fails to run in emacs 29.4

[Dov Grobgeld]

Thanks João,

You pushed me finally fix the my use-package installation, and once I
did that everything worked.

I'll close the bug.

On Mon, Sep 23, 2024 at 9:02 PM João Távora <joaotavora@gmail.com> wrote:
>
> Dov, I don't know where you may have obtained the idea that this eval-buffer activation method is supported. It isn't.
>
> Eglot has dependencies, so either use package.el facilities to ensure that they are installed and activated or use Emacs master. IIRC, in Emacs 29.4 one can use M-x eglot-upgrade-eglot to get and activate the latest version from GNU Elpa (or GNU-devel Elpa) correctly. Other methods are not supported.
>
>
> On Mon, Sep 23, 2024, 12:58 Eli Zaretskii <eliz@gnu.org> wrote:
>>
>> > From: Dov Grobgeld <dov.grobgeld@gmail.com>
>> > Date: Mon, 23 Sep 2024 11:58:03 +0300
>> >
>> > Running the latest version of eglot, version 1.17, installed by
>> > package-list-packages, on emacs 29.4 fails.
>>
>> Adding João.
>>
>> > Here's what I did:
>> >
>> > $ cd /tmp/eglot-1.17
>> > $ emacs -Q -nw eglot.el
>> >
>> > and then the interactive commands
>> >
>> > M-x eval-buffer
>> > C-x C-f hello.c
>> > C-: (setq debug-on-error t)
>> > M-x eglot
>> >
>> > This resulted in an error. Here is the stack trace:
>> >
>> > Debugger entered--Lisp error: (invalid-slot-name "#<eglot-lsp-server
>> > eglot-lsp-server-93e4e78>" :events-buffer-config)
>> >   signal(invalid-slot-name ("#<eglot-lsp-server
>> > eglot-lsp-server-93e4e78>" :events-buffer-config))
>> >   slot-missing(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > :events-buffer-config oset (:size 2000000 :format full))
>> >   #f(compiled-function (obj slots) "Set slots of OBJ with SLOTS which
>> > is a list of name/value pairs.\nCalled from the constructor routine."
>> > #<bytecode 0x4590eddf9051ddd>)(#<eglot-lsp-server
>> > eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
>> > c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   apply(#f(compiled-function (obj slots) "Set slots of OBJ with SLOTS
>> > which is a list of name/value pairs.\nCalled from the constructor
>> > routine." #<bytecode 0x4590eddf9051ddd>) #<eglot-lsp-server
>> > eglot-lsp-server-93e4e78> (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode
>> > c++-mode c++-t..." :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   shared-initialize(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   #f(compiled-function (this &optional args) "Construct the new object
>> > THIS based on ARGS.\nARGS is a property list where odd numbered
>> > elements are tags, and\neven numbered elements are the values to store
>> > in the tagged slot.\nIf you overload the `initialize-instance', there
>> > you will need to\ncall `shared-initialize' yourself, or you can call
>> > `call-next-method'\nto have this constructor called automatically.  If
>> > these steps are\nnot taken, then new objects of your class will not
>> > have their values\ndynamically set from ARGS." #<bytecode
>> > -0x1f60eebd0e85d7f7>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   apply(#f(compiled-function (this &optional args) "Construct the new
>> > object THIS based on ARGS.\nARGS is a property list where odd numbered
>> > elements are tags, and\neven numbered elements are the values to store
>> > in the tagged slot.\nIf you overload the `initialize-instance', there
>> > you will need to\ncall `shared-initialize' yourself, or you can call
>> > `call-next-method'\nto have this constructor called automatically.  If
>> > these steps are\nnot taken, then new objects of your class will not
>> > have their values\ndynamically set from ARGS." #<bytecode
>> > -0x1f60eebd0e85d7f7>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t))))))
>> >   #f(compiled-function (&rest args) #<bytecode -0x7469b45b80fef61>)()
>> >   #f(compiled-function (cl--cnm conn slots) #<bytecode
>> > 0x18a7bfd9b312194c>)(#f(compiled-function (&rest args) #<bytecode
>> > -0x7469b45b80fef61>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   apply(#f(compiled-function (cl--cnm conn slots) #<bytecode
>> > 0x18a7bfd9b312194c>) #f(compiled-function (&rest args) #<bytecode
>> > -0x7469b45b80fef61>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t))))))
>> >   #f(compiled-function (conn slots) #<bytecode
>> > 0x164956dec53e81bc>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   apply(#f(compiled-function (conn slots) #<bytecode
>> > 0x164956dec53e81bc>) (#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t))))))
>> >   #f(compiled-function (&rest args) #<bytecode
>> > -0xb77c4438ff27908>)(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   apply(#f(compiled-function (&rest args) #<bytecode
>> > -0xb77c4438ff27908>) #<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   initialize-instance(#<eglot-lsp-server eglot-lsp-server-93e4e78>
>> > (:name "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   #f(compiled-function (class &rest slots) "Default constructor for
>> > CLASS `eieio-default-superclass'.\nSLOTS are the initialization slots
>> > used by `initialize-instance'.\nThis static method is called when an
>> > object is constructed.\nIt allocates the vector used to represent an
>> > EIEIO object, and then\ncalls `initialize-instance' on that object."
>> > #<bytecode -0x982733269180e59>)(eglot-lsp-server :name "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
>> > (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
>> > eglot-handle-notification)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
>> > :process (closure ((contact "/usr/bin/clangd") (server-info)
>> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
>> > c++-t...") tramp-ssh-controlmaster-options
>> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
>> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t))))
>> >   apply(#f(compiled-function (class &rest slots) "Default constructor
>> > for CLASS `eieio-default-superclass'.\nSLOTS are the initialization
>> > slots used by `initialize-instance'.\nThis static method is called
>> > when an object is constructed.\nIt allocates the vector used to
>> > represent an EIEIO object, and then\ncalls `initialize-instance' on
>> > that object." #<bytecode -0x982733269180e59>) eglot-lsp-server (:name
>> > "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..."
>> > :events-buffer-config (:size 2000000 :format full)
>> > :notification-dispatcher (closure ((fn . eglot-handle-notification))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :request-dispatcher (closure ((fn
>> > . eglot-handle-request)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :on-shutdown eglot--on-shutdown :process (closure ((contact
>> > "/usr/bin/clangd") (server-info) (readable-name . "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t...")
>> > tramp-ssh-controlmaster-options tramp-use-ssh-controlmaster-options)
>> > nil (let ((default-directory default-directory)
>> > (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   make-instance(eglot-lsp-server :name "EGLOT (eglot-1.17/(c-mode
>> > c-ts-mode c++-mode c++-t..." :events-buffer-config (:size 2000000
>> > :format full) :notification-dispatcher (closure ((fn .
>> > eglot-handle-notification)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
>> > :process (closure ((contact "/usr/bin/clangd") (server-info)
>> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
>> > c++-t...") tramp-ssh-controlmaster-options
>> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
>> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t))))
>> >   apply(make-instance eglot-lsp-server :name "EGLOT
>> > (eglot-1.17/(c-mode c-ts-mode c++-mode c++-t..." :events-buffer-config
>> > (:size 2000000 :format full) :notification-dispatcher (closure ((fn .
>> > eglot-handle-notification)) (server method params) (let
>> > ((eglot--cached-server server)) (apply fn server method (append params
>> > nil)))) :request-dispatcher (closure ((fn . eglot-handle-request))
>> > (server method params) (let ((eglot--cached-server server)) (apply fn
>> > server method (append params nil)))) :on-shutdown eglot--on-shutdown
>> > (:process (closure ((contact "/usr/bin/clangd") (server-info)
>> > (readable-name . "EGLOT (eglot-1.17/(c-mode c-ts-mode c++-mode
>> > c++-t...") tramp-ssh-controlmaster-options
>> > tramp-use-ssh-controlmaster-options) nil (let ((default-directory
>> > default-directory) (tramp-use-ssh-controlmaster-options 'suppress)
>> > (tramp-ssh-controlmaster-options "-o ControlMaster=no -o
>> > ControlPath=none")) (make-process :name readable-name :command (setq
>> > server-info (eglot--cmd contact)) :connection-type 'pipe :coding
>> > 'utf-8-emacs-unix :noquery t :stderr (get-buffer-create (format "*%s
>> > stderr*" readable-name)) :file-handler t)))))
>> >   (let* ((default-directory (project-root project)) (nickname
>> > (project-name project)) (readable-name (format "EGLOT (%s/%s)"
>> > nickname managed-modes)) server-info (contact (if (functionp contact)
>> > (funcall contact) contact)) (initargs (cond ((keywordp (car contact))
>> > contact) ((integerp (car (cdr contact))) (setq server-info (list
>> > (format "%s:%s" ... ...))) (list ':process #'(lambda nil ...))) ((and
>> > (stringp (car contact)) (cl-find-if #'... contact)) (setq server-info
>> > (list "<inferior process>")) (list ':process
>> > (jsonrpc-autoport-bootstrap readable-name contact :connect-args
>> > '...))) ((stringp (car contact)) (let* ((probe ...) (more-initargs
>> > ...) (contact ...)) (cons ':process (cons ... more-initargs))))))
>> > (spread #'(lambda (fn) #'(lambda (server method params) (let ...
>> > ...)))) (server (apply #'make-instance class :name readable-name
>> > :events-buffer-config eglot-events-buffer-config
>> > :notification-dispatcher (funcall spread #'eglot-handle-notification)
>> > :request-dispatcher (funcall spread #'eglot-handle-request)
>> > :on-shutdown #'eglot--on-shutdown initargs)) (canceled nil) (tag
>> > (make-symbol "connected-catch-tag"))) (if server-info (progn
>> > (jsonrpc--debug server "Running language server: %s" (string-join
>> > server-info " ")))) (let* ((v server)) (\(setf\
>> > eglot--saved-initargs\) initargs v)) (let* ((v server)) (\(setf\
>> > eglot--project\) project v)) (let* ((v server)) (\(setf\
>> > eglot--project-nickname\) nickname v)) (let* ((v server)) (\(setf\
>> > eglot--languages\) (let* ((--cl-var-- managed-modes) (m nil)
>> > (--cl-var-- language-ids) (l nil) (--cl-var-- nil)) (while (and (consp
>> > --cl-var--) (progn (setq m ...) (consp --cl-var--))) (setq l (car
>> > --cl-var--)) (setq --cl-var-- (cons (cons m l) --cl-var--)) (setq
>> > --cl-var-- (cdr --cl-var--)) (setq --cl-var-- (cdr --cl-var--)))
>> > (nreverse --cl-var--)) v)) (run-hook-with-args
>> > 'eglot-server-initialized-hook server) (unwind-protect (condition-case
>> > _quit (let ((retval (catch tag (jsonrpc-async-request server
>> > :initialize ... :success-fn ... :timeout eglot-connect-timeout
>> > :error-fn ... :timeout-fn ...) (cond ... ...)))) (cond ((consp retval)
>> > (let* (...) (if ... ... ...))) ((null retval) (let nil (eglot--message
>> > "Waiting in background for server `%s'" ...) nil)) (t (let nil
>> > server)))) (quit (jsonrpc-shutdown server) (setq canceled 'quit)))
>> > (setq tag nil)))
>> >   eglot--connect((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode)
>> > (transient . "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd")
>> > ("c" "c" "c++" "c++" "objc"))
>> >   eglot((c-mode c-ts-mode c++-mode c++-ts-mode objc-mode) (transient .
>> > "/tmp/eglot-1.17/") eglot-lsp-server ("/usr/bin/clangd") ("c" "c"
>> > "c++" "c++" "objc") t)
>> >   funcall-interactively(eglot (c-mode c-ts-mode c++-mode c++-ts-mode
>> > objc-mode) (transient . "/tmp/eglot-1.17/") eglot-lsp-server
>> > ("/usr/bin/clangd") ("c" "c" "c++" "c++" "objc") t)
>> >   command-execute(eglot record)
>> >   execute-extended-command(nil "eglot" "eglot")
>> >   funcall-interactively(execute-extended-command nil "eglot" "eglot")
>> >   command-execute(execute-extended-command)
>> >
>> >
>> >
>> >

bug#73436: eglot-1.17 fails to run in emacs 29.4

[Eli Zaretskii]

> From: Dov Grobgeld <dov.grobgeld@gmail.com>
> Date: Mon, 23 Sep 2024 22:29:15 +0300
> Cc: Eli Zaretskii <eliz@gnu.org>, 73436@debbugs.gnu.org
> 
> Thanks João,
> 
> You pushed me finally fix the my use-package installation, and once I
> did that everything worked.
> 
> I'll close the bug.

Thanks, closing.