From: Eli Zaretskii <eliz@gnu.org>
Date: Sat, 15 Apr 2023 17:02:04 +0000 (-0400)
Subject: Merge from origin/emacs-29
X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=7191318b716debaca15b56ebf7b13f5a1b07b0f9;p=emacs.git

Merge from origin/emacs-29

864a4dc2363 Fix compilation of w32.c with old MinGW system headers
a22eb9ae0f9 ruby-add-log-current-method: Reduce the use of 'nreverse'
17d803d0a75 Fix detection of WebP images by their signature
43290391ce2 ; Eglot: make version parseable by version-to-list
6e6e8b5c974 Add more documentation for the keys of `package-vc-select...
7972b76c2c7 ; vc-checkout: Wrap var lookup in 'bound-and-true-p'
e9fef1d70ff vc-checkout: Try to use the vc-dir's backend first
372e024accd ; Fix wallpaper-tests on XFCE
7055fd8e43e Improve documentation related to 'ispell-complete-word'
61fd017abde * configure.ac: Add -lbsd on Haiku.
05971c4d9a4 Add menu to 'c-ts-mode' and 'c++-ts-mode'

# Conflicts:
#	lisp/progmodes/eglot.el
#	lisp/progmodes/ruby-mode.el
---

7191318b716debaca15b56ebf7b13f5a1b07b0f9
diff --cc lisp/progmodes/c-ts-mode.el
index 600650aadc1,2d54577cb09..5a38d714e5a
--- a/lisp/progmodes/c-ts-mode.el
+++ b/lisp/progmodes/c-ts-mode.el
@@@ -1064,12 -1029,43 +1064,45 @@@ recommended to enable `electric-pair-mo
      ;; Indent.
      (setq-local treesit-simple-indent-rules
                  (c-ts-mode--get-indent-style 'cpp))
 +
      ;; Font-lock.
      (setq-local treesit-font-lock-settings (c-ts-mode--font-lock-settings 'cpp))
 +
      (treesit-major-mode-setup)))
  
+ (easy-menu-define c-ts-mode-menu (list c-ts-mode-map c++-ts-mode-map)
+   "Menu for `c-ts-mode' and `c++-ts-mode'."
+   '("C/C++"
+     ["Comment Out Region" comment-region
+      :enable mark-active
+      :help "Comment out the region between the mark and point"]
+     ["Uncomment Region" (comment-region (region-beginning)
+                                         (region-end) '(4))
+      :enable mark-active
+      :help "Uncomment the region between the mark and point"]
+     ["Indent Top-level Expression" c-ts-mode-indent-defun
+      :help "Indent/reindent top-level function, class, etc."]
+     ["Indent Line or Region" indent-for-tab-command
+      :help "Indent current line or region, or insert a tab"]
+     ["Forward Expression" forward-sexp
+      :help "Move forward across one balanced expression"]
+     ["Backward Expression" backward-sexp
+      :help "Move back across one balanced expression"]
+     "--"
+     ("Style..."
+      ["Set Indentation Style..." c-ts-mode-set-style
+       :help "Set C/C++ indentation style for current buffer"]
+      ["Show Current Indentation Style" (message "Indentation Style: %s"
+                                                 c-ts-mode-indent-style)
+       :help "Show the name of the C/C++ indentation style for current buffer"]
+      ["Set Comment Style" c-ts-mode-toggle-comment-style
+       :help "Toglle C/C++ comment style between block and line comments"])
+     "--"
+     ("Toggle..."
+      ["SubWord Mode" subword-mode
+       :style toggle :selected subword-mode
+       :help "Toggle sub-word movement and editing mode"])))
+ 
  ;; We could alternatively use parsers, but if this works well, I don't
  ;; see the need to change.  This is copied verbatim from cc-guess.el.
  (defconst c-ts-mode--c-or-c++-regexp
diff --cc lisp/progmodes/ruby-mode.el
index d2c4da794ac,b252826680c..e441ffbbfe3
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@@ -1850,92 -1850,93 +1850,92 @@@ For example
    File.open
  
  See `add-log-current-defun-function'."
 -  (condition-case nil
 -      (save-excursion
 -        (let* ((indent (ruby--add-log-current-indent))
 -               mname mlist
 -               (start (point))
 -               (make-definition-re
 -                (lambda (re &optional method-name?)
 -                  (concat "^[ \t]*" re "[ \t]+"
 -                          "\\("
 -                          ;; \\. and :: for class methods
 -                          "\\([A-Za-z_]" ruby-symbol-re "*[?!]?"
 -                          "\\|"
 -                          (if method-name? ruby-operator-re "\\.")
 -                          "\\|::" "\\)"
 -                          "+\\)")))
 -               (definition-re (funcall make-definition-re ruby-defun-beg-re t))
 -               (module-re (funcall make-definition-re "\\(class\\|module\\)")))
 -          ;; Get the current method definition (or class/module).
 -          (when (catch 'found
 -                  (while (and (re-search-backward definition-re nil t)
 -                              (if (if (string-equal "def" (match-string 1))
 -                                      ;; We're inside a method.
 -                                      (if (ruby-block-contains-point (1- start))
 -                                          t
 -                                        ;; Try to match a method only once.
 -                                        (setq definition-re module-re)
 -                                        nil)
 -                                    ;; Class/module. For performance,
 -                                    ;; comparing indentation.
 -                                    (or (not (numberp indent))
 -                                        (> indent (current-indentation))))
 -                                  (throw 'found t)
 -                                t))))
 -            (goto-char (match-beginning 1))
 -            (if (not (string-equal "def" (match-string 1)))
 -                (setq mlist (list (match-string 2)))
 -              (setq mname (match-string 2)))
 -            (setq indent (current-column))
 -            (beginning-of-line))
 -          ;; Walk up the class/module nesting.
 -          (while (and indent
 -                      (> indent 0)
 -                      (re-search-backward module-re nil t))
 -            (goto-char (match-beginning 1))
 -            (when (< (current-column) indent)
 -              (setq mlist (cons (match-string 2) mlist))
 -              (setq indent (current-column))
 -              (beginning-of-line)))
 -          ;; Process the method name.
 -          (when mname
 -            (let ((mn (split-string mname "\\.\\|::")))
 -              (if (cdr mn)
 -                  (progn
 -                    (unless (string-equal "self" (car mn)) ; def self.foo
 -                      ;; def C.foo
 -                      (let ((ml (reverse mlist)))
 -                        ;; If the method name references one of the
 -                        ;; containing modules, drop the more nested ones.
 -                        (while ml
 -                          (if (string-equal (car ml) (car mn))
 -                              (setq mlist (nreverse (cdr ml)) ml nil))
 -                          (setq ml (cdr ml))))
 -                      (if mlist
 -                          (setcdr (last mlist) (butlast mn))
 -                        (setq mlist (butlast mn))))
 -                    (setq mname (concat "." (car (last mn)))))
 -                ;; See if the method is in singleton class context.
 -                (let ((in-singleton-class
 -                       (when (re-search-forward ruby-singleton-class-re start t)
 -                         (goto-char (match-beginning 0))
 -                         ;; FIXME: Optimize it out, too?
 -                         ;; This can be slow in a large file, but
 -                         ;; unlike class/module declaration
 -                         ;; indentations, method definitions can be
 -                         ;; intermixed with these, and may or may not
 -                         ;; be additionally indented after visibility
 -                         ;; keywords.
 -                         (ruby-block-contains-point start))))
 -                  (setq mname (concat
 -                               (if in-singleton-class "." "#")
 -                               mname))))))
 -          ;; Generate the string.
 -          (if (consp mlist)
 -              (setq mlist (mapconcat (function identity) mlist "::")))
 -          (if mname
 -              (if mlist (concat mlist mname) mname)
 -            mlist)))))
 +  (save-excursion
 +    (let* ((indent (ruby--add-log-current-indent))
 +           mname mlist
 +           (start (point))
 +           (make-definition-re
 +            (lambda (re &optional method-name?)
 +              (concat "^[ \t]*" re "[ \t]+"
 +                      "\\("
 +                      ;; \\. and :: for class methods
 +                      "\\([A-Za-z_]" ruby-symbol-re "*[?!]?"
 +                      "\\|"
 +                      (if method-name? ruby-operator-re "\\.")
 +                      "\\|::" "\\)"
 +                      "+\\)")))
 +           (definition-re (funcall make-definition-re ruby-defun-beg-re t))
 +           (module-re (funcall make-definition-re "\\(class\\|module\\)")))
 +      ;; Get the current method definition (or class/module).
 +      (when (catch 'found
 +              (while (and (re-search-backward definition-re nil t)
 +                          (if (if (string-equal "def" (match-string 1))
 +                                  ;; We're inside a method.
 +                                  (if (ruby-block-contains-point (1- start))
 +                                      t
 +                                    ;; Try to match a method only once.
 +                                    (setq definition-re module-re)
 +                                    nil)
 +                                ;; Class/module. For performance,
 +                                ;; comparing indentation.
 +                                (or (not (numberp indent))
 +                                    (> indent (current-indentation))))
 +                              (throw 'found t)
 +                            t))))
 +        (goto-char (match-beginning 1))
 +        (if (not (string-equal "def" (match-string 1)))
 +            (setq mlist (list (match-string 2)))
 +          (setq mname (match-string 2)))
 +        (setq indent (current-column))
 +        (beginning-of-line))
 +      ;; Walk up the class/module nesting.
 +      (while (and indent
 +                  (> indent 0)
 +                  (re-search-backward module-re nil t))
 +        (goto-char (match-beginning 1))
 +        (when (< (current-column) indent)
 +          (setq mlist (cons (match-string 2) mlist))
 +          (setq indent (current-column))
 +          (beginning-of-line)))
 +      ;; Process the method name.
 +      (when mname
 +        (let ((mn (split-string mname "\\.\\|::")))
 +          (if (cdr mn)
 +              (progn
 +                (unless (string-equal "self" (car mn)) ; def self.foo
 +                  ;; def C.foo
-                   (let ((ml (nreverse mlist)))
++                  (let ((ml (reverse mlist)))
 +                    ;; If the method name references one of the
 +                    ;; containing modules, drop the more nested ones.
 +                    (while ml
 +                      (if (string-equal (car ml) (car mn))
 +                          (setq mlist (nreverse (cdr ml)) ml nil))
-                       (or (setq ml (cdr ml)) (nreverse mlist))))
++                      (setq ml (cdr ml))))
 +                  (if mlist
 +                      (setcdr (last mlist) (butlast mn))
 +                    (setq mlist (butlast mn))))
 +                (setq mname (concat "." (car (last mn)))))
 +            ;; See if the method is in singleton class context.
 +            (let ((in-singleton-class
 +                   (when (re-search-forward ruby-singleton-class-re start t)
 +                     (goto-char (match-beginning 0))
 +                     ;; FIXME: Optimize it out, too?
 +                     ;; This can be slow in a large file, but
 +                     ;; unlike class/module declaration
 +                     ;; indentations, method definitions can be
 +                     ;; intermixed with these, and may or may not
 +                     ;; be additionally indented after visibility
 +                     ;; keywords.
 +                     (ruby-block-contains-point start))))
 +              (setq mname (concat
 +                           (if in-singleton-class "." "#")
 +                           mname))))))
 +      ;; Generate the string.
 +      (if (consp mlist)
 +          (setq mlist (mapconcat (function identity) mlist "::")))
 +      (if mname
 +          (if mlist (concat mlist mname) mname)
 +        mlist))))
  
  (defun ruby-block-contains-point (pt)
    (save-excursion