commit cc589d70039af48332699428cbce352fe890eb2c (HEAD, refs/remotes/origin/master)
Author: Elías Gabriel Pérez <eg642616@gmail.com>
Date:   Sat Oct 25 10:46:56 2025 -0600

    hideshow: Rework previous changes
    
    * doc/emacs/programs.texi (Hideshow):
    * etc/NEWS: Fix doc.
    * lisp/progmodes/hideshow.el: Update Commentary Header.
    (hs-modes-alist): Remove.
    (hs--get-mode-value, hs-grok-mode-type): Rework.
    * lisp/treesit.el (treesit-major-mode-setup):
    * lisp/emacs-lisp/lisp-mode.el:
    * lisp/nxml/nxml-mode.el:
    * lisp/progmodes/cc-mode.el:
    * lisp/progmodes/f90.el:
    * lisp/progmodes/fortran.el:
    * lisp/progmodes/hideshow.el:
    * lisp/progmodes/icon.el:
    * lisp/progmodes/js.el:
    * lisp/progmodes/lua-mode.el:
    * lisp/progmodes/python.el:
    * lisp/progmodes/verilog-mode.el:
    * lisp/progmodes/vhdl-mode.el:
    * lisp/textmodes/bibtex.el:
    * lisp/textmodes/mhtml-mode.el:
    * lisp/textmodes/sgml-mode.el:
    * lisp/treesit.el: Fix and rework previous changes.

diff --git a/doc/emacs/programs.texi b/doc/emacs/programs.texi
index 12bde32be05..f08a3834c17 100644
--- a/doc/emacs/programs.texi
+++ b/doc/emacs/programs.texi
@@ -1688,8 +1688,9 @@ row).  Just what constitutes a block depends on the major mode.  In C
 mode and related modes, blocks are delimited by braces, while in Lisp
 mode they are delimited by parentheses.  Multi-line comments also
 count as blocks.
+@vindex hs-prefix-map
 
-  Hideshow mode provides the following commands:
+  Hideshow mode provides the following commands (defined in @code{hs-prefix-map}):
 
 @findex hs-hide-all
 @findex hs-hide-block
@@ -1735,7 +1736,6 @@ Hide all blocks @var{n} levels below this block
 @vindex hs-indicator-maximum-buffer-size
 @vindex hs-isearch-open
 @vindex hs-hide-block-behavior
-@vindex hs-modes-alist
   These variables can be used to customize Hideshow mode:
 
 @table @code
@@ -1782,9 +1782,6 @@ code blocks and comments), or @code{nil} (unhide neither code blocks
 nor comments).  The default value is @code{code}.
 @end table
 
-All necessary settings for each mode can be found in the variable
-@code{hs-modes-alist}.
-
 @node Symbol Completion
 @section Completion for Symbol Names
 @cindex completion (symbol names)
diff --git a/etc/NEWS b/etc/NEWS
index ed504118e66..0dbe168d8c1 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1108,9 +1108,6 @@ after cursor position.  By default this is set to 'after-bol'.
 
 +++
 *** The variable 'hs-special-modes-alist' is now obsolete.
-Use the new variable 'hs-modes-alist' instead, which supports mode
-hierarchy for each value.
-
 
 ** C-ts mode
 
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index e4dfc7c2f78..0756c0f908f 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -729,7 +729,9 @@ font-lock keywords will not be case sensitive."
   :group 'lisp
   (lisp-mode-variables nil t nil)
   (setq-local electric-quote-string t)
-  (setq imenu-case-fold-search nil))
+  (setq imenu-case-fold-search nil)
+  (setq-local hs-block-start-regexp "\\s(\\|\"")
+  (setq-local hs-block-end-regexp "\\s)\\|\""))
 
 (defun lisp-outline-level ()
   "Lisp mode `outline-level' function."
diff --git a/lisp/nxml/nxml-mode.el b/lisp/nxml/nxml-mode.el
index ae27824fdc9..08c6c1b2fac 100644
--- a/lisp/nxml/nxml-mode.el
+++ b/lisp/nxml/nxml-mode.el
@@ -532,6 +532,10 @@ Many aspects this mode can be customized using
   (setq-local comment-line-break-function #'nxml-newline-and-indent)
   (setq-local comment-quote-nested-function #'nxml-comment-quote-nested)
   (setq-local comment-continue "") ; avoid double-hyphens as a padding
+  (setq-local hs-block-start-regexp "<[^/>]*?")
+  (setq-local hs-block-end-regexp "</[^/>]*[^/]>")
+  (setq-local hs-c-start-regexp "<!--")
+  (setq-local hs-forward-sexp-func #'sgml-skip-tag-forward)
   (save-excursion
     (save-restriction
       (widen)
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 9c89a7db4b7..76071d54f9c 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -252,7 +252,11 @@ control).  See \"cc-mode.el\" for more info."
             (when (fboundp 'electric-indent-local-mode)
 	      (add-hook 'electric-indent-mode-hook 'c-electric-indent-mode-hook)
               (add-hook 'electric-indent-local-mode-hook
-                        'c-electric-indent-local-mode-hook)))
+                        'c-electric-indent-local-mode-hook))
+	    ;; Setup hideshow variables
+	    (setq-local hs-block-start-regexp "\\s(\\|{\\|\"")
+	    (setq-local hs-block-end-regexp "\\s)\\|}\\|\"")
+	    (setq-local hs-c-start-regexp "/[*/]"))
 	;; Will try initialization hooks again if they failed.
 	(put 'c-initialize-cc-mode initprop c-initialization-ok))))
 
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index c3158069dcd..d5cdbb3bf42 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -930,7 +930,7 @@ allowed.  This minor issue currently only affects \"(/\" and \"/)\".")
                         "block" "critical") t)
           "\\_>")
   "Regexp matching the end of an F90 \"block\", from the line start.
-Used in the F90 entry in `hs-modes-alist'.")
+Used in the F90 entry in `hs-block-end-regexp'.")
 
 ;; Ignore the fact that FUNCTION, SUBROUTINE, WHERE, FORALL have a
 ;; following "(".  DO, CASE, IF can have labels.
@@ -966,12 +966,7 @@ Used in the F90 entry in `hs-modes-alist'.")
   "Regexp matching the start of an F90 \"block\", from the line start.
 A simple regexp cannot do this in fully correct fashion, so this
 tries to strike a compromise between complexity and flexibility.
-Used in the F90 entry in `hs-modes-alist'.")
-
-;; hs-modes-alist is autoloaded.
-(add-to-list 'hs-modes-alist
-             `(f90-mode (start . ,f90-start-block-re) (end . ,f90-end-block-re)
-                        (c-start . "!") (forward-fn . f90-end-of-block)))
+Used in the F90 entry in `hs-block-start-regexp'.")
 
 
 ;; Imenu support.
@@ -1188,7 +1183,11 @@ with no args, if that value is non-nil."
   (setq-local imenu-generic-expression f90-imenu-generic-expression)
   (setq-local beginning-of-defun-function #'f90-beginning-of-subprogram)
   (setq-local end-of-defun-function #'f90-end-of-subprogram)
-  (setq-local add-log-current-defun-function #'f90-current-defun))
+  (setq-local add-log-current-defun-function #'f90-current-defun)
+  (setq-local hs-block-start-regexp f90-start-block-re)
+  (setq-local hs-block-end-regexp f90-end-block-re)
+  (setq-local hs-c-start-regexp "!")
+  (setq-local hs-forward-sexp-func #'f90-end-of-block))
 
 
 ;; Inline-functions.
diff --git a/lisp/progmodes/fortran.el b/lisp/progmodes/fortran.el
index 6eb75af01a3..18813257400 100644
--- a/lisp/progmodes/fortran.el
+++ b/lisp/progmodes/fortran.el
@@ -549,7 +549,7 @@ than ENDDO.")
           "\\|!\\|$\\)")
   "Regexp matching the end of a Fortran \"block\", from the line start.
 Note that only ENDDO is handled for the end of a DO-loop.  Used
-in the Fortran entry in `hs-modes-alist'.")
+in the Fortran entry in `hs-block-end-regexp'.")
 
 (defconst fortran-start-block-re
   (concat
@@ -582,11 +582,7 @@ in the Fortran entry in `hs-modes-alist'.")
   "Regexp matching the start of a Fortran \"block\", from the line start.
 A simple regexp cannot do this in fully correct fashion, so this
 tries to strike a compromise between complexity and flexibility.
-Used in the Fortran entry in `hs-modes-alist'.")
-
-(add-to-list 'hs-modes-alist
-             `(fortran-mode (start . ,fortran-start-block-re) (end . ,fortran-end-block-re)
-                            (c-start . "^[cC*!]") (forward-fn . fortran-end-of-block)))
+Used in the Fortran entry in `hs-block-start-regexp'.")
 
 
 (defvar fortran-mode-syntax-table
@@ -837,7 +833,11 @@ with no args, if that value is non-nil."
               #'fortran-current-defun)
   (setq-local dabbrev-case-fold-search 'case-fold-search)
   (setq-local gud-find-expr-function 'fortran-gud-find-expr)
-  (add-hook 'hack-local-variables-hook 'fortran-hack-local-variables nil t))
+  (add-hook 'hack-local-variables-hook 'fortran-hack-local-variables nil t)
+  (setq-local hs-block-start-regexp fortran-start-block-re)
+  (setq-local hs-block-end-regexp fortran-end-block-re)
+  (setq-local hs-c-start-regexp "^[cC*!]")
+  (setq-local hs-forward-sexp-func #' fortran-end-of-block))
 
 
 (defun fortran-line-length (nchars &optional global)
@@ -1247,7 +1247,7 @@ Directive lines are treated as comments."
           (goto-char i)
           (= (line-beginning-position) p)))))
 
-;; Used in hs-modes-alist.
+;; Used in hs-forward-sexp-func.
 (defun fortran-end-of-block (&optional num)
   "Move point forward to the end of the current code block.
 With optional argument NUM, go forward that many balanced blocks.
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 8efcdec36a4..89305a1d313 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -40,6 +40,9 @@
 ;;   `hs-toggle-hiding'                   S-<mouse-2>
 ;;   `hs-hide-initial-comment-block'
 ;;
+;; All these commands are defined in `hs-prefix-map',
+;; `hs-minor-mode-map' and `hs-indicators-map'.
+;;
 ;; Blocks are defined per mode.  In c-mode, c++-mode and java-mode, they
 ;; are simply text between curly braces, while in Lisp-ish modes parens
 ;; are used.  Multi-line comment blocks can also be hidden.  Read-only
@@ -86,6 +89,14 @@
 ;;                                         is called with no arguments
 ;; - `hs-isearch-open'                  -- what kind of hidden blocks to
 ;;                                         open when doing isearch
+;; - `hs-display-lines-hidden'          -- displays the number of hidden
+;;                                         lines next to the ellipsis.
+;; - `hs-show-indicators'               -- display indicators to show
+;;                                         and toggle the block hiding.
+;; - `hs-indicator-type'                -- which indicator type should be
+;;                                         used for the block indicators.
+;; - `hs-indicator-maximum-buffer-size' -- max buffer size in bytes where
+;;                                         the indicators should be enabled.
 ;;
 ;; Some languages (e.g., Java) are deeply nested, so the normal behavior
 ;; of `hs-hide-all' (hiding all but top-level blocks) results in very
@@ -122,19 +133,6 @@
 ;; respectively.  All hooks are run with `run-hooks'.  See the
 ;; documentation for each variable or hook for more information.
 ;;
-;; Normally, hideshow tries to determine appropriate values for block
-;; and comment definitions by examining the buffer's major mode.  If
-;; there are problems, hideshow will not activate and in that case you
-;; may wish to override hideshow's heuristics by adding an entry to
-;; variable `hs-special-modes-alist'.  Packages that use hideshow should
-;; do something like:
-;;
-;;   (add-to-list 'hs-special-modes-alist '(my-mode "{{" "}}" ...))
-;;
-;; If you have an entry that works particularly well, consider
-;; submitting it for inclusion in hideshow.el.  See docstring for
-;; `hs-special-modes-alist' for more info on the entry format.
-;;
 ;; See also variable `hs-set-up-overlay' for per-block customization of
 ;; appearance or other effects associated with overlays.  For example:
 ;;
@@ -148,6 +146,41 @@
 ;;                                              (overlay-end ov)))
 ;;                         'face 'font-lock-type-face)))))
 
+;; * Adding support for a major mode
+;;
+;; Normally, hideshow tries to determine appropriate values for block
+;; and comment definitions by examining the major mode settings.  If the
+;; major mode is not derived from `prog-mode', hideshow will not
+;; activate.  If you want to override this, you can set any of the
+;; following variables: `hs-block-start-regexp',
+;; `hs-block-start-mdata-select', `hs-block-end-regexp',
+;; `hs-c-start-regexp', `hs-forward-sexp-func',
+;; `hs-adjust-block-beginning', `hs-adjust-block-end',
+;; `hs-find-block-beginning-func', `hs-find-next-block-func',
+;; `hs-looking-at-block-start-p-func', `hs-inside-comment-p-func',
+;; `hs-treesit-things'.
+;;
+;; These variables help hideshow know what is considered a block, which
+;; function to use to get the block positions, etc.
+;;
+;; A block is defined as text surrounded by `hs-block-start-regexp' and
+;; `hs-block-end-regexp'.
+;;
+;; For some major modes, forward-sexp does not work properly.  In those
+;; cases, `hs-forward-sexp-func' specifies another function to use
+;; instead.
+
+;; ** Tree-sitter support
+;;
+;; All the treesit based modes already have support for hidding/showing
+;; using the treesit thing `list' (see `treesit-major-mode-setup').
+;;
+;; However, for some modes the `list' thing is not enough for detecting
+;; the proper code block and the range to hide, you can set the variable
+;; `hs-treesit-things' to override this, but ensure you have the proper
+;; values in `hs-adjust-block-end' and `hs-adjust-block-beginning' to
+;; properly hide the code block.
+
 ;; * Bugs
 ;;
 ;; (1) Sometimes `hs-headline' can become out of sync.  To reset, type
@@ -371,83 +404,9 @@ This is only used if `hs-indicator-type' is set to `margin' or nil."
 
 ;;;###autoload
 (defvar hs-special-modes-alist nil)
-(make-obsolete-variable 'hs-special-modes-alist 'hs-modes-alist "31.1")
-
-;;;###autoload
-(defvar hs-modes-alist
-  '((c-mode (start . "\\s(\\|{\\|\"")
-            (end . "\\s)\\|}\\|\"")
-            (c-start . "/[*/]"))
-    (c++-mode (start . "\\s(\\|{\\|\"")
-              (end . "\\s)\\|}\\|\"")
-              (c-start . "/[*/]"))
-    (java-mode    (start . "\\s(\\|{\\|\"")
-                  (end . "\\s)\\|}\\|\"")
-                  (c-start . "/[*/]"))
-    (js-base-mode (start . "\\s(\\|{\\|\"")
-                  (end . "\\s)\\|}\\|\"")
-                  (c-start . "/[*/]"))
-    (bibtex-mode  (start . ("@\\S(*\\(\\s(\\)" 1)))
-    (sgml-mode (start . "<[^/>]*?") (end . "</[^/>]*[^/]>")
-               (c-start . "<!--") (forward-fn . sgml-skip-tag-forward))
-    (mhtml-mode (start . "{\\|<[^/>]*?") (end . "}\\|</[^/>]*[^/]>")
-                (forward-fn . mhtml-forward))
-    (lisp-data-mode (start . "\\s(\\|\"") (end . "\\s)\\|\""))
-    ;; Add more support here.
-    )
-  "Alist for initializing the hideshow variables for different modes.
-Each element is an alist with any of the cons-cells forms:
- (MODE &optional
-       (start . START)
-       (end . END)
-       (c-start . COMMENT-START)
-       (forward-fn . FORWARD-SEXP-FUNC)
-       (adjust-beg-fn . ADJUST-BEG-FUNC)
-       (adjust-end-fn . ADJUST-END-FUNC)
-       (find-beg-fn . FIND-BLOCK-BEGINNING-FUNC)
-       (find-next-fn . FIND-NEXT-BLOCK-FUNC)
-       (look-start-fn . LOOKING-AT-BLOCK-START-P-FUNC)
-       (commentp . INSIDE-COMMENT-P-FUNC)
-       (treesit-things . TREESIT-THINGS))
-
-If non-nil, hideshow will use these values as regexps to define blocks
-and comments, respectively for major mode MODE and its derivatives.
-
-START, END and COMMENT-START are regular expressions.  A block is
-defined as text surrounded by START and END.
-
-As a special case, START may be a list of the form (COMPLEX-START
-MDATA-SELECTOR), where COMPLEX-START is a regexp with multiple parts and
-MDATA-SELECTOR an integer that specifies which sub-match is the proper
-place to adjust point, before calling `hs-forward-sexp-func'.  Point
-is adjusted to the beginning of the specified match.  For example,
-see the `hs-modes-alist' entry for `bibtex-mode'.
-
-For some major modes, `forward-sexp' does not work properly.  In those
-cases, FORWARD-SEXP-FUNC specifies another function to use instead.
-
-See `hs-adjust-block-beginning' for how to use ADJUST-BEG-FUNC,
-and `hs-adjust-block-end' for how to use ADJUST-END-FUNC.
-
-See `hs-find-block-beginning-func' for how to use FIND-BLOCK-BEGINNING-FUNC
-and `hs-find-next-block-func' for how to use FIND-NEXT-BLOCK-FUNC.
-
-See `hs-looking-at-block-start-p-func' for how to use
-LOOKING-AT-BLOCK-START-P-FUNC and `hs-inside-comment-p-func' for how to
-use INSIDE-COMMENT-P-FUNC.
-
-TREESIT-THINGS is a thing defined in `treesit-thing-settings' to
-determine if the block at point is valid, see `treesit-thing-settings'
-for more information.
-
-All the elements support mode hierarchy.  If any of the elements is left
-nil or omitted, hideshow searches for a value defined in some parent
-mode in this alist; if no value is found, it tries to guess the
-appropriate value.  The regexps should not contain leading or trailing
-whitespace.  Letter-case does not matter.")
-
-(defvar hs-hide-all-non-comment-function nil
-  "Function called if non-nil when doing `hs-hide-all' for non-comments.")
+(make-obsolete-variable 'hs-special-modes-alist
+                        "use the buffer-local variables instead"
+                        "31.1")
 
 (defcustom hs-allow-nesting nil
   "If non-nil, hiding remembers internal blocks.
@@ -554,21 +513,53 @@ Use the command `hs-minor-mode' to toggle or set this variable.")
       :help "Do not hidden code or comment blocks when isearch matches inside them"
       :active t :style radio :selected (eq hs-isearch-open nil)])))
 
-(defvar-local hs-c-start-regexp nil
-  "Regexp for beginning of comments.
-Differs from mode-specific comment regexps in that
-surrounding whitespace is stripped.")
+(defvar hs-hide-all-non-comment-function nil
+  "Function called if non-nil when doing `hs-hide-all' for non-comments.")
+
+(defvar hs-headline nil
+  "Text of the line where a hidden block begins, set during isearch.
+You can display this in the mode line by adding the symbol `hs-headline'
+to the variable `mode-line-format'.  For example,
+
+  (unless (memq \\='hs-headline mode-line-format)
+    (setq mode-line-format
+          (append \\='(\"-\" hs-headline) mode-line-format)))
+
+Note that `mode-line-format' is buffer-local.")
+
+;;---------------------------------------------------------------------------
+;; API variables
 
 (defvar-local hs-block-start-regexp nil
-  "Regexp for beginning of block.")
+  "Regexp for beginning of block.
+
+It should not contain leading or trailing whitespace.
+Letter-case does not matter.
+
+If not bound, this will be set to \"\\s(\".")
 
 (defvar-local hs-block-start-mdata-select nil
   "Element in `hs-block-start-regexp' match data to consider as block start.
 The internal function `hs-forward-sexp' moves point to the beginning of this
-element (using `match-beginning') before calling `hs-forward-sexp-func'.")
+element (using `match-beginning') before calling `hs-forward-sexp-func'.
+
+If not bound, this will be set to 0")
 
 (defvar-local hs-block-end-regexp nil
-  "Regexp for end of block.")
+  "Regexp for end of block.
+
+It should not contain leading or trailing whitespace.
+Letter-case does not matter.
+
+If not bound, this will be set to \"\\s)\"")
+
+(defvar-local hs-c-start-regexp nil
+  "Regexp for beginning of comments.
+Differs from mode-specific comment regexps in that surrounding
+whitespace is stripped.
+
+If not bound, hideshow will use current `comment-start' value without
+any surrounding whitespace.")
 
 (defvar-local hs-forward-sexp-func nil
   "Function used to do a `forward-sexp'.
@@ -576,7 +567,9 @@ Should change for Algol-ish modes.  For single-character block
 delimiters -- ie, the syntax table regexp for the character is
 either `(' or `)' -- `hs-forward-sexp-func' would just be
 `forward-sexp'.  For other modes such as simula, a more specialized
-function is necessary.")
+function is necessary.
+
+If not bound, this will be set to `forward-sexp'.")
 
 (defvar-local hs-adjust-block-beginning nil
   "Function used to tweak the block beginning.
@@ -596,7 +589,9 @@ It should return the position from where we should start hiding.
 
 It should not move the point.
 
-See `hs-c-like-adjust-block-beginning' for an example of using this.")
+See `hs-c-like-adjust-block-beginning' for an example of using this.
+
+If not bound, this will be set to nil.")
 
 (defvar-local hs-adjust-block-end nil
   "Function used to tweak the block end.
@@ -605,7 +600,9 @@ braces get properly hidden in python-like modes.
 
 It is called with one argument, which is the start position where the
 overlay will be created, and should return either the last position to
-hide or nil.  If it returns nil, hideshow will guess the end position.")
+hide or nil.  If it returns nil, hideshow will guess the end position.
+
+If not bound, this will be set to nil.")
 
 (defvar-local hs-find-block-beginning-func nil
   "Function used to do `hs-find-block-beginning'.
@@ -614,7 +611,9 @@ and return point, or nil if original point was not in a block.
 
 Specifying this function is necessary for languages such as
 Python, where regexp search and `syntax-ppss' check is not enough
-to find the beginning of the current block.")
+to find the beginning of the current block.
+
+If not bound, this will be set to `hs-find-block-beginning'.")
 
 (defvar-local hs-find-next-block-func nil
   "Function used to do `hs-find-next-block'.
@@ -630,7 +629,9 @@ this case, the function should find nearest block or comment.
 
 Specifying this function is necessary for languages such as
 Python, where regexp search is not enough to find the beginning
-of the next block.")
+of the next block.
+
+If not bound, this will be set to `hs-find-next-block'.")
 
 (defvar-local hs-looking-at-block-start-p-func nil
   "Function used to do `hs-looking-at-block-start-p'.
@@ -638,7 +639,9 @@ It should return non-nil if the point is at the block start.
 
 Specifying this function is necessary for languages such as
 Python, where `looking-at' and `syntax-ppss' check is not enough
-to check if the point is at the block start.")
+to check if the point is at the block start.
+
+If not bound, this will be set to `hs-looking-at-block-start-p'.")
 
 (defvar-local hs-inside-comment-p-func nil
   "Function used to check if point is inside a comment.
@@ -649,23 +652,16 @@ comment, otherwise it should return nil.
 A comment block can be hidden only if on its starting line there is only
 whitespace preceding the actual comment beginning.  If point is inside
 a comment but this condition is not met, the function can return a list
-having nil as its `car' and the end of comment position as its `cdr'.")
+having nil as its `car' and the end of comment position as its `cdr'.
+
+If not bound, this will be set to `hs-inside-comment-p--default'.")
 
 (defvar-local hs-treesit-things nil
   "Treesit things to check if point is at a valid block.
 The value should be a thing defined in `treesit-thing-settings' for the
-current buffer's major mode.")
+current buffer's major mode.
 
-(defvar hs-headline nil
-  "Text of the line where a hidden block begins, set during isearch.
-You can display this in the mode line by adding the symbol `hs-headline'
-to the variable `mode-line-format'.  For example,
-
-  (unless (memq \\='hs-headline mode-line-format)
-    (setq mode-line-format
-          (append \\='(\"-\" hs-headline) mode-line-format)))
-
-Note that `mode-line-format' is buffer-local.")
+If not bound, this will be set to \\='list.")
 
 ;;---------------------------------------------------------------------------
 ;; support functions
@@ -747,7 +743,8 @@ point."
           ;; `block-start' is the point at the end of the block
           ;; beginning, which may need to be adjusted
           (save-excursion
-            (goto-char (funcall hs-adjust-block-beginning header-end))
+            (when hs-adjust-block-beginning
+              (goto-char (funcall hs-adjust-block-beginning header-end)))
             (setq block-beg (line-end-position)))
           ;; `block-end' is the point at the end of the block
           (hs-forward-sexp mdata 1)
@@ -759,8 +756,12 @@ point."
                        (funcall hs-block-end-regexp)
                        (match-beginning 0))
                       (t (point))))
-          (cons block-beg
-                (or (funcall hs-adjust-block-end block-beg) block-end)))))))
+          ;; adjust block end (if needed)
+          (when hs-adjust-block-end
+            (setq block-end
+                  (or (funcall hs-adjust-block-end block-beg)
+                      block-end)))
+          (cons block-beg block-end))))))
 
 (defun hs--make-indicators-overlays (beg)
   "Helper function to make the indicators overlays."
@@ -1019,33 +1020,32 @@ Otherwise, return nil."
           (when (>= (point) q)
             (list (and hideable p) (point))))))))
 
-(defun hs--get-mode-value (value &optional old-nth)
-  "Get VALUE for current major mode in `hs-modes-alist'.
+(defun hs--get-mode-value (var default &optional old-nth)
+  "Get VAR value for current major mode in `hs-special-modes-alist'.
+DEFAULT is a value to use as fallback.
 OLD-NTH is only used for backward compatibility with
 `hs-special-modes-alist'."
-  (if-let* (old-nth
-            (old-lookup (assoc major-mode hs-special-modes-alist)))
-      (nth old-nth old-lookup)
-    (catch 'hs-grok-exit
-      (dolist (modes (get major-mode 'derived-mode--all-parents))
-        ;; If we cannot find VALUE in current MODES, try to find it in
-        ;; the next mode in MODES
-        (if-let* ((list (assoc modes hs-modes-alist))
-                  (elm (alist-get value list)))
-            (throw 'hs-grok-exit elm))))))
+  (if (local-variable-p var)
+      (symbol-value var)
+    (if-let* (old-nth
+              (old-lookup (assoc major-mode hs-special-modes-alist)))
+        (nth old-nth old-lookup)
+      default)))
 
 (defun hs-grok-mode-type ()
   "Set up hideshow variables for new buffers.
-If `hs-modes-alist' has information associated with the
-current buffer's major mode, use that.
-Otherwise, guess start, end and `comment-start' regexps; `forward-sexp'
-function; and adjust-block-beginning function."
+If `hs-special-modes-alist' has information associated with the current
+buffer's major mode, use that.  Otherwise, guess start, end and
+`comment-start' regexps; `forward-sexp' function; and
+adjust-block-beginning function."
   (if (and (bound-and-true-p comment-start)
            (bound-and-true-p comment-end))
-      (let ((start-elem (ensure-list (hs--get-mode-value 'start 1))))
+      (let ((start-elem (cadr (assoc major-mode hs-special-modes-alist))))
         ;; If some these variables are already set, use them instead.
         (setq
          ;; handle (START-REGEXP MDATA-SELECT) and simple START-REGEXP
+         ;; TEMP: At the moment, we cannot use `hs--get-mode-value'
+         ;; here.
          hs-block-start-regexp
          (if (local-variable-p 'hs-block-start-regexp)
              hs-block-start-regexp
@@ -1057,59 +1057,49 @@ function; and adjust-block-beginning function."
            (or (cadr start-elem) 0))
 
          hs-block-end-regexp
-         (if (local-variable-p 'hs-block-end-regexp)
-             hs-block-end-regexp
-           (or (hs--get-mode-value 'end 2) "\\s)"))
+         (hs--get-mode-value 'hs-block-end-regexp "\\s)" 2)
 
          hs-c-start-regexp
-         (if (local-variable-p 'hs-c-start-regexp)
-             hs-c-start-regexp
-           (or (hs--get-mode-value 'c-start 3)
-               (let ((c-start-regexp
-                      (regexp-quote comment-start)))
-                 (if (string-match " +$" c-start-regexp)
-                     (substring c-start-regexp
-                                0 (1- (match-end 0)))
-                   c-start-regexp))))
+         (hs--get-mode-value
+          'hs-c-start-regexp
+          (let ((c-start-regexp
+                 (regexp-quote comment-start)))
+            (if (string-match " +$" c-start-regexp)
+                (substring c-start-regexp
+                           0 (1- (match-end 0)))
+              c-start-regexp))
+          3)
 
          hs-forward-sexp-func
-         (if (local-variable-p 'hs-forward-sexp-func)
-             hs-forward-sexp-func
-           (or (hs--get-mode-value 'forward-fn 4)
-               #'forward-sexp))
+         (hs--get-mode-value 'hs-forward-sexp-func #'forward-sexp 4)
 
          hs-adjust-block-beginning
-         (or (hs--get-mode-value 'adjust-fn 5) #'identity)
+         (hs--get-mode-value 'hs-adjust-block-beginning nil 5)
 
          hs-adjust-block-end
-         (or (hs--get-mode-value 'adjust-end-fn) #'ignore)
+         (hs--get-mode-value 'hs-adjust-block-end nil)
 
          hs-find-block-beginning-func
-         (if (local-variable-p 'hs-find-block-beginning-func)
-             hs-find-block-beginning-func
-           (or (hs--get-mode-value 'find-beg-fn 6)
-               #'hs-find-block-beginning))
+         (hs--get-mode-value 'hs-find-block-beginning-func
+                             #'hs-find-block-beginning
+                             6)
 
          hs-find-next-block-func
-         (if (local-variable-p 'hs-find-next-block-func)
-             hs-find-next-block-func
-           (or (hs--get-mode-value 'find-next-fn 7)
-               #'hs-find-next-block))
+         (hs--get-mode-value 'hs-find-next-block-func
+                             #'hs-find-next-block
+                             7)
 
          hs-looking-at-block-start-p-func
-         (if (local-variable-p 'hs-looking-at-block-start-p-func)
-             hs-looking-at-block-start-p-func
-           (or (hs--get-mode-value 'look-start-fn 8)
-               #'hs-looking-at-block-start-p))
+         (hs--get-mode-value 'hs-looking-at-block-start-p-func
+                             #'hs-looking-at-block-start-p
+                             8)
 
          hs-inside-comment-p-func
-         (if (local-variable-p 'hs-inside-comment-p-func)
-             hs-inside-comment-p-func
-           (or (hs--get-mode-value 'commentp)
-               #'hs-inside-comment-p--default))
+         (hs--get-mode-value 'hs-inside-comment-p-func
+                             #'hs-inside-comment-p--default)
 
          hs-treesit-things
-         (or (hs--get-mode-value 'treesit-things) 'list)))
+         (hs--get-mode-value 'hs-treesit-things 'list)))
 
     (setq hs-minor-mode nil)
     (error "%S doesn't support Hideshow Minor Mode" major-mode)))
@@ -1431,7 +1421,7 @@ Key bindings:
   (setq hs-headline nil)
   (if hs-minor-mode
       (progn
-        ;; Set the variables according to `hs-modes-alist'.
+        ;; Set the variables
         (hs-grok-mode-type)
         ;; Turn off this mode if we change major modes.
         (add-hook 'change-major-mode-hook
diff --git a/lisp/progmodes/icon.el b/lisp/progmodes/icon.el
index 2a5172609d9..fac7a92a5f5 100644
--- a/lisp/progmodes/icon.el
+++ b/lisp/progmodes/icon.el
@@ -167,12 +167,9 @@ with no args, if that value is non-nil."
   ;; imenu support
   (setq-local imenu-generic-expression icon-imenu-generic-expression)
   ;; hideshow support
-  ;; we start from the assertion that `hs-modes-alist' is autoloaded.
-  (unless (assq 'icon-mode hs-modes-alist)
-    (setq hs-modes-alist
-	  (cons '(icon-mode  (start . "\\<procedure\\>") (end . "\\<end\\>")
-                             (forward-fn . icon-forward-sexp-function))
-		hs-modes-alist))))
+  (setq-local hs-block-start-regexp "\\<procedure\\>")
+  (setq-local hs-block-end-regexp "\\<end\\>")
+  (setq-local hs-forward-sexp-func #'icon-forward-sexp-function))
 
 ;; This is used by indent-for-comment to decide how much to
 ;; indent a comment in Icon code based on its context.
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index 1a81fa6c7fa..c9e9d3febaf 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -3832,7 +3832,9 @@ Return nil if there is no name or if NODE is not a defun node."
 This mode is intended to be inherited by concrete major modes.
 Currently there are `js-mode' and `js-ts-mode'."
   :group 'js
-  nil)
+  (setq-local hs-block-start-regexp "\\s(\\|{\\|\"")
+  (setq-local hs-block-end-regexp "\\s)\\|}\\|\"")
+  (setq-local hs-c-start-regexp "/[*/]"))
 
 ;;;###autoload
 (define-derived-mode js-mode js-base-mode "JavaScript"
diff --git a/lisp/progmodes/lua-mode.el b/lisp/progmodes/lua-mode.el
index 07b3777c988..ac71950988f 100644
--- a/lisp/progmodes/lua-mode.el
+++ b/lisp/progmodes/lua-mode.el
@@ -553,12 +553,9 @@ See `imenu-generic-expression'.")
   (add-hook 'flymake-diagnostic-functions #'lua-flymake nil t)
 
   ;; Hide-show setup
-  (unless (assq 'lua-mode hs-modes-alist)
-    (add-to-list 'hs-modes-alist
-                 `(lua-mode
-                   (start . ,(regexp-opt (mapcar 'car lua-sexp-alist) 'words)) ; Start
-                   (end . ,(regexp-opt (mapcar 'cdr lua-sexp-alist) 'words)) ; End
-                   (forward-fn . lua-forward-sexp)))))
+  (setq-local hs-block-start-regexp (regexp-opt (mapcar 'car lua-sexp-alist) 'words))
+  (setq-local hs-block-end-regexp (regexp-opt (mapcar 'cdr lua-sexp-alist) 'words))
+  (setq-local hs-forward-sexp-func #'lua-forward-sexp))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '("\\.lua\\'" . lua-mode))
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index f73a0128b5c..f34fb28826f 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -7355,24 +7355,15 @@ implementations: `python-mode' and `python-ts-mode'."
                       #'python-eldoc-function))))
   (eldoc-add-command-completions "python-indent-dedent-line-backspace")
 
-  (add-to-list
-   'hs-modes-alist
-   `(python-mode
-     (start . ,python-nav-beginning-of-block-regexp)
-     ;; Use the empty string as end regexp so it doesn't default to
-     ;; "\\s)".  This way parens at end of defun are properly hidden.
-     (end . "")
-     (c-start . "#")
-     (forward-fn . python-hideshow-forward-sexp-function)
-     (find-beg-fn . python-nav-beginning-of-block)
-     (find-next-fn . python-hideshow-find-next-block)
-     (look-start-fn . python-info-looking-at-beginning-of-block)))
-
-  (add-to-list
-   'hs-modes-alist
-   '(python-ts-mode
-     (treesit-things . (or defun sexp))
-     (adjust-end-fn . python-ts-hs-adjust-block-end-fn)))
+  (setq-local hs-block-start-regexp python-nav-beginning-of-block-regexp)
+  ;; Use the empty string as end regexp so it doesn't default to
+  ;; "\\s)".  This way parens at end of defun are properly hidden.
+  (setq-local hs-block-end-regexp "")
+  (setq-local hs-c-start-regexp "#")
+  (setq-local hs-forward-sexp-func #'python-hideshow-forward-sexp-function)
+  (setq-local hs-find-block-beginning-func #'python-nav-beginning-of-block)
+  (setq-local hs-find-next-block-func #'python-hideshow-find-next-block)
+  (setq-local hs-looking-at-block-start-p-func #'python-info-looking-at-beginning-of-block)
 
   (setq-local outline-regexp (python-rx (* space) block-start))
   (setq-local outline-level
@@ -7446,6 +7437,9 @@ implementations: `python-mode' and `python-ts-mode'."
     (setq-local forward-sexp-function #'treesit-forward-sexp
                 treesit-sexp-thing 'sexp)
 
+    (setq-local hs-treesit-things '(or defun sexp))
+    (setq-local hs-adjust-block-end #'python-ts-hs-adjust-block-end-fn)
+
     (setq-local syntax-propertize-function #'python--treesit-syntax-propertize)
 
     (python-skeleton-add-menu-items)
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 81fecec806f..09a3ec56899 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -4363,12 +4363,9 @@ Key bindings specific to `verilog-mode-map' are:
   (when (and (boundp 'which-func-modes) (listp which-func-modes))
     (add-to-list 'which-func-modes 'verilog-mode))
   ;; hideshow support
-  (when (boundp 'hs-modes-alist)
-    (unless (assq 'verilog-mode hs-modes-alist)
-      (setq hs-modes-alist
-            (cons '(verilog-mode (beg . "\\<begin\\>") (end . "\\<end\\>")
-                                 (forward-fn . verilog-forward-sexp-function))
-                  hs-modes-alist))))
+  (setq-local hs-block-start-regexp "\\<begin\\>")
+  (setq-local hs-block-end-regexp "\\<end\\>")
+  (setq-local hs-forward-sexp-func #'verilog-forward-sexp-function)
 
   (add-hook 'completion-at-point-functions
             #'verilog-completion-at-point nil 'local)
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 82e6f41e07e..969ac78833a 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -13282,11 +13282,9 @@ File statistics: \"%s\"\n\
   (if (not (boundp 'hs-block-start-mdata-select))
       (vhdl-warning-when-idle "Install included `hideshow.el' patch first (see INSTALL file)")
     ;; initialize hideshow
-    (unless (assoc 'vhdl-mode hs-modes-alist)
-      (setq hs-modes-alist
-	    (cons `(vhdl-mode (start . ,vhdl-hs-start-regexp) (c-start . "--\\( \\|$\\)")
-			      (forward-fn . vhdl-hs-forward-sexp-func))
-		  hs-modes-alist)))
+    (setq-local hs-block-start-regexp vhdl-hs-start-regexp)
+    (setq-local hs-c-start-regexp "--\\( \\|$\\)")
+    (setq-local hs-forward-sexp-func #'vhdl-hs-forward-sexp-func)
     (if (featurep 'xemacs) (make-local-hook 'hs-minor-mode-hook))
     (if vhdl-hide-all-init
 	(add-hook 'hs-minor-mode-hook #'hs-hide-all nil t)
diff --git a/lisp/textmodes/bibtex.el b/lisp/textmodes/bibtex.el
index 32ae730cd4a..c8e21884be2 100644
--- a/lisp/textmodes/bibtex.el
+++ b/lisp/textmodes/bibtex.el
@@ -3661,6 +3661,8 @@ if that value is non-nil.
   (setq-local comment-column 0)
   (setq-local defun-prompt-regexp "^[ \t]*@[[:alnum:]]+[ \t]*")
   (setq-local outline-regexp "[ \t]*@")
+  (setq-local hs-block-start-regexp "@\\S(*\\(\\s(\\)")
+  (setq-local hs-block-end-regexp 1)
   (setq-local fill-paragraph-function #'bibtex-fill-field)
   (setq-local font-lock-defaults
               '(bibtex-font-lock-keywords
diff --git a/lisp/textmodes/mhtml-mode.el b/lisp/textmodes/mhtml-mode.el
index 4ab560df6a8..e4fe383e149 100644
--- a/lisp/textmodes/mhtml-mode.el
+++ b/lisp/textmodes/mhtml-mode.el
@@ -306,7 +306,7 @@ This is used by `mhtml--pre-command'.")
         (flyspell-generic-progmode-verify)
       t)))
 
-;; Support for hideshow.el (see `hs-modes-alist').
+;; Support for hideshow.el (see `hs-forward-sexp-func').
 (defun mhtml-forward (arg)
   "Move point forward past a structured expression.
 If point is on a tag, move to the end of the tag.
@@ -329,6 +329,9 @@ the rules from `css-mode'."
   (setq-local syntax-propertize-function #'mhtml-syntax-propertize)
   (setq-local font-lock-fontify-region-function
               #'mhtml--submode-fontify-region)
+  (setq-local hs-block-start-regexp "{\\|<[^/>]*?")
+  (setq-local hs-block-end-regexp "}\\|</[^/>]*[^/]>")
+  (setq-local hs-forward-sexp-func #'mhtml-forward)
 
   ;; Attach this to both pre- and post- hooks just in case it ever
   ;; changes a key binding that might be accessed from the menu bar.
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index 2accd31bc36..1044bba42e7 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -667,7 +667,11 @@ Do \\[describe-key] on the following bindings to discover what they do.
 	   ,(concat "<[^>]+[ \t\n]+[Nn][Aa][Mm][Ee]=\\(['\"]"
 		    (if sgml-xml-mode "" "?")
 		    "\\)\\(" sgml-name-re "\\)\\1")
-	   2))))
+	   2)))
+  (setq-local hs-block-start-regexp "<[^/>]*?")
+  (setq-local hs-block-end-regexp "</[^/>]*[^/]>")
+  (setq-local hs-c-start-regexp "<!--")
+  (setq-local hs-forward-sexp-func #'sgml-skip-tag-forward))
 
 (defun sgml-comment-indent ()
   (if (looking-at "--") comment-column 0))
diff --git a/lisp/treesit.el b/lisp/treesit.el
index 969b1b6dcc8..360b74f2a47 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -4514,10 +4514,8 @@ before calling this function."
     (setq-local show-paren-data-function #'treesit-show-paren-data)
     (setq-local hs-c-start-regexp nil
                 hs-block-start-regexp nil
-                hs-block-start-mdata-select 0
                 hs-block-end-regexp #'treesit-hs-block-end
                 hs-forward-sexp-func #'forward-list
-                hs-adjust-block-beginning nil
                 hs-find-block-beginning-func #'treesit-hs-find-block-beginning
                 hs-find-next-block-func #'treesit-hs-find-next-block
                 hs-looking-at-block-start-p-func #'treesit-hs-looking-at-block-start-p

commit 2c41bfabbcf9972f32844d53ba6ddf99c3be47a5
Author: Juri Linkov <juri@linkov.net>
Date:   Thu Nov 6 09:30:37 2025 +0200

    Don't move point when clicking on hideshow fringe/margin indicator
    
    * lisp/progmodes/hideshow.el (hs-indicator-mouse-toggle-hidding):
    Enclose in 'hs-life-goes-on' (bug#79585).
    Suggested by Elijah Gabe Pérez <eg642616@gmail.com>.

diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index f3850c0f3d8..8efcdec36a4 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -1378,17 +1378,18 @@ Argument E should be the event that triggered this action."
 (defun hs-indicator-mouse-toggle-hidding (event)
   "Toggle block hidding with indicators."
   (interactive "e")
-  (when hs-show-indicators
-    (let* ((overlays (save-excursion
-                       (goto-char (posn-point (event-end event)))
-                       (overlays-in (pos-bol) (pos-eol))))
-           (pos (catch 'hs--indicator-ov
-                  (dolist (ov overlays)
-                    (when-let* ((ov (overlay-get ov 'hs-indicator-block-start)))
-                      (throw 'hs--indicator-ov ov))))))
-      (when pos
-        (goto-char pos)
-        (hs-toggle-hiding)))))
+  (hs-life-goes-on
+   (when hs-show-indicators
+     (let* ((overlays (save-excursion
+                        (goto-char (posn-point (event-end event)))
+                        (overlays-in (pos-bol) (pos-eol))))
+            (pos (catch 'hs--indicator-ov
+                   (dolist (ov overlays)
+                     (when-let* ((ov (overlay-get ov 'hs-indicator-block-start)))
+                       (throw 'hs--indicator-ov ov))))))
+       (when pos
+         (goto-char pos)
+         (hs-toggle-hiding))))))
 
 (defun hs-hide-initial-comment-block ()
   "Hide the first block of comments in a file.

commit d6402072f2d0f83b6dae110d80f08d42900d31f7
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Thu Nov 6 08:36:50 2025 +0200

    A better fix for recent changes in Gnulib's acl_entries.c
    
    See https://lists.gnu.org/archive/html/emacs-devel/2025-11/msg00145.html
    for the related discussions.
    * nt/mingw-cfg.site (ac_cv_func_acl_entries): Set to "yes" to
    disable compilation of lib/acl_entries.c on MinGW.
    
    * lib/acl_entries.c (acl_entries): Revert last change, as it is no
    longer needed.

diff --git a/lib/acl_entries.c b/lib/acl_entries.c
index f9619c0f539..b78ba18a656 100644
--- a/lib/acl_entries.c
+++ b/lib/acl_entries.c
@@ -44,7 +44,7 @@ acl_entries (acl_t acl)
            got_one >= 0;
            got_one = acl_get_entry (acl, ACL_NEXT_ENTRY, &ace))
         count++;
-#elif !defined __MINGW32__ /* Linux, FreeBSD, NetBSD >= 10, Cygwin >= 2.5 */
+#else /* Linux, FreeBSD, NetBSD >= 10, Cygwin >= 2.5 */
       /* acl_get_entry returns 1 when it successfully fetches an entry,
          and 0 at the end.  */
       acl_entry_t ace;
diff --git a/nt/mingw-cfg.site b/nt/mingw-cfg.site
index 16b61de3bd0..7829a9878fe 100644
--- a/nt/mingw-cfg.site
+++ b/nt/mingw-cfg.site
@@ -46,12 +46,13 @@ ac_cv_search_clock_gettime="none required"
 ac_cv_func_clock_gettime=no
 ac_cv_func_clock_settime=no
 
-# ACL functions are implemented in w32.c
+# ACL functions are either implemented in w32.c or not needed
 ac_cv_search_acl_get_file="none required"
 ac_cv_func_acl_get_file=yes
 ac_cv_func_acl_set_file=yes
 ac_cv_func_acl_free=yes
 ac_cv_func_acl_from_text=yes
+ac_cv_func_acl_entries=yes
 gl_cv_func_working_acl_get_file=yes
 # Autoconf's test program is not smart enough, and fails to detect gethostname
 ac_cv_func_gethostname=yes

commit 58a2c2494d32719841ac3aa7a463e1a49852510c
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Thu Nov 6 08:01:32 2025 +0200

    ; * lisp/emacs-lisp/loaddefs-gen.el (loaddefs-generate): Doc fix.

diff --git a/lisp/emacs-lisp/loaddefs-gen.el b/lisp/emacs-lisp/loaddefs-gen.el
index 04fd7f30881..d4c0a87e6f9 100644
--- a/lisp/emacs-lisp/loaddefs-gen.el
+++ b/lisp/emacs-lisp/loaddefs-gen.el
@@ -594,17 +594,17 @@ If COMPILE, don't include a \"don't compile\" cookie."
 
 ;;;###autoload
 (defun loaddefs-generate (dirs output-file &optional excluded-files
-                              extra-data include-package-version
-                              generate-full)
-  "Generate loaddefs files for Lisp files in one or more directories given by DIR.
-DIR can be either a single directory or a list of directories.
+                               extra-data include-package-version
+                               generate-full)
+  "Generate loaddefs files for Lisp files in directories given by DIRS.
+DIRS can be either a single directory or a list of directories.
 
 The autoloads will be written to OUTPUT-FILE.  If any Lisp file
 binds `generated-autoload-file' as a file-local variable, write
 its autoloads into the specified file instead.
 
-The function does NOT recursively descend into subdirectories of the
-directories specified by DIR.
+This function does NOT recursively descend into subdirectories of the
+directories specified by DIRS.
 
 Optional argument EXCLUDED-FILES, if non-nil, should be a list of
 files, such as preloaded files, whose autoloads should not be written
@@ -636,9 +636,9 @@ instead of just updating them with the new/changed autoloads."
          (updating (and (file-exists-p output-file) (not generate-full)))
          (defs nil))
     ;; Allow the excluded files to be relative.
-    ;; We used to do (expand-file-name file dir), which strangely enough
-    ;; doesn't signal an error when DIR is a list but does something weird
-    ;; instead, so let's preserve the old behavior when DIR is a string,
+    ;; We used to do (expand-file-name file dirs), which strangely enough
+    ;; doesn't signal an error when DIRS is a list but does something weird
+    ;; instead, so let's preserve the old behavior when DIRS is a string,
     ;; even tho it's different from what we do when it's a list.
     (let ((basedir (if (stringp dirs) dirs)))
       (setq excluded-files

commit 34ab8abdd24deb56cfb9474630fa7704e7a7b22e
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Sun Oct 26 17:44:19 2025 -0400

    (loaddefs-generate--emacs-batch): Chdir to `lisp-directory`
    
    Chdir once and for all at the beginning to simplify the code.
    Eliminate some redundant `expand-file-name`s and fix a broken use
    of `expand-file-name` where we passed a list as second arg.
    
    * lisp/emacs-lisp/loaddefs-gen.el (loaddefs-generate): Rename DIR to
    DIRS, to clarify that it can be a list.  Use `ensure-list`.
    Don't pass DIR(S) directly to `expand-file-name`.
    Remove redundant `expand-file-name`.
    (loaddefs-generate--excluded-files): Add sanity checks.
    Return relative file names since `loaddefs-generate` will make them
    absolute anyway.  Simplify.
    (loaddefs-generate--emacs-batch): Chdir to `lisp-directory` and
    simplify the rest accordingly.

diff --git a/lisp/emacs-lisp/loaddefs-gen.el b/lisp/emacs-lisp/loaddefs-gen.el
index c8e05921fc1..04fd7f30881 100644
--- a/lisp/emacs-lisp/loaddefs-gen.el
+++ b/lisp/emacs-lisp/loaddefs-gen.el
@@ -593,7 +593,7 @@ If COMPILE, don't include a \"don't compile\" cookie."
       (buffer-string))))
 
 ;;;###autoload
-(defun loaddefs-generate (dir output-file &optional excluded-files
+(defun loaddefs-generate (dirs output-file &optional excluded-files
                               extra-data include-package-version
                               generate-full)
   "Generate loaddefs files for Lisp files in one or more directories given by DIR.
@@ -632,13 +632,18 @@ instead of just updating them with the new/changed autoloads."
 		       (mapcar (lambda (d)
 				 (directory-files (expand-file-name d)
                                                   t files-re))
-			       (if (consp dir) dir (list dir)))))
+			       (ensure-list dirs))))
          (updating (and (file-exists-p output-file) (not generate-full)))
          (defs nil))
     ;; Allow the excluded files to be relative.
-    (setq excluded-files
-          (mapcar (lambda (file) (expand-file-name file dir))
-                  excluded-files))
+    ;; We used to do (expand-file-name file dir), which strangely enough
+    ;; doesn't signal an error when DIR is a list but does something weird
+    ;; instead, so let's preserve the old behavior when DIR is a string,
+    ;; even tho it's different from what we do when it's a list.
+    (let ((basedir (if (stringp dirs) dirs)))
+      (setq excluded-files
+            (mapcar (lambda (file) (expand-file-name file basedir))
+                    excluded-files)))
 
     ;; Collect all the autoload data.
     (let ((progress (make-progress-reporter
@@ -657,7 +662,7 @@ instead of just updating them with the new/changed autoloads."
                                 (file-attributes file))))
           ;; If we're scanning for package versions, we want to look
           ;; at the file even if it's excluded.
-          (let* ((excluded (member (expand-file-name file dir) excluded-files))
+          (let* ((excluded (member file excluded-files))
                  (package-data
                   (and include-package-version (if excluded 'only t))))
             (when (or package-data (not excluded))
@@ -724,7 +729,7 @@ instead of just updating them with the new/changed autoloads."
           (unless (equal (buffer-hash) hash)
             (write-region (point-min) (point-max) loaddefs-file nil 'silent)
             (byte-compile-info
-             (file-relative-name loaddefs-file (car (ensure-list dir)))
+             (file-relative-name loaddefs-file (car (ensure-list dirs)))
              t "GEN")))))
 
     ;; If processing files without any autoloads, the above loop will
@@ -776,19 +781,21 @@ instead of just updating them with the new/changed autoloads."
   ;; Exclude those files that are preloaded on ALL platforms.
   ;; These are the ones in loadup.el where "(load" is at the start
   ;; of the line (crude, but it works).
-  (let ((default-directory (file-name-directory lisp-directory))
-        (excludes nil)
-	file)
+  (unless (equal default-directory (file-name-as-directory lisp-directory))
+    (error "PWD is not set as expected: %S" default-directory))
+  (let ((excludes nil))
     (with-temp-buffer
       (insert-file-contents "loadup.el")
+      (when (= (point-min) (point-max)) (error "Can't find loadup.el"))
       (while (re-search-forward "^(load \"\\([^\"]+\\)\"" nil t)
-	(setq file (match-string 1))
-	(or (string-match "\\.el\\'" file)
-	    (setq file (format "%s.el" file)))
-	(or (string-match "\\`site-" file)
-	    (push (expand-file-name file) excludes))))
+	(let ((file (match-string 1)))
+	  (unless (string-match "\\`site-" file)
+	    (push (if (string-match "\\.el\\'" file)
+	              file
+	            (format "%s.el" file))
+	          excludes)))))
     ;; Don't scan ldefs-boot.el, either.
-    (cons (expand-file-name "ldefs-boot.el") excludes)))
+    (cons "ldefs-boot.el" excludes)))
 
 ;;;###autoload
 (defun loaddefs-generate-batch ()
@@ -806,8 +813,12 @@ use."
   "Generate the loaddefs for the Emacs build.
 This is like `loaddefs-generate-batch', but has some specific
 rules for built-in packages and excluded files."
-  (let ((args command-line-args-left)
-        (output-file (expand-file-name "loaddefs.el" lisp-directory)))
+  (let* ((args command-line-args-left)
+         ;; We're run from $BUILDDIR/lisp but all the .el(c) files reside
+         ;; (and are generated) in `lisp-directory' which is in $SRCDIR,
+         ;; so go there and don't look back.
+         (default-directory lisp-directory)
+         (output-file (expand-file-name "loaddefs.el")))
     (setq command-line-args-left nil)
     (loaddefs-generate
      args output-file
@@ -817,12 +828,12 @@ rules for built-in packages and excluded files."
      ;; updated.
      (file-newer-than-file-p
       (expand-file-name "emacs-lisp/loaddefs-gen.el" lisp-directory)
-      output-file)))
-  (let ((lisp-mode-autoload-regexp
-         "^;;;###\\(\\(noexist\\)-\\)?\\(theme-autoload\\)"))
+      output-file))
+    (let ((lisp-mode-autoload-regexp
+           "^;;;###\\(\\(noexist\\)-\\)?\\(theme-autoload\\)"))
       (loaddefs-generate
-       (expand-file-name "../etc/themes/" lisp-directory)
-       (expand-file-name "theme-loaddefs.el" lisp-directory))))
+       (expand-file-name "../etc/themes/")
+       (expand-file-name "theme-loaddefs.el")))))
 
 ;;;###autoload (load "theme-loaddefs.el" t)
 

commit 02253b35afb685f05a77e282bc6a07c621021970
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Wed Nov 5 15:11:27 2025 -0500

    (load-history, lisp-directory): Don't `file-truename`
    
    This fixes problems in some cases of out-f-tree builds
    (bug#79694, bug#62099, bug#64806).
    
    The use of true names in `load-history` dates back to to commits
    33d74677e739 and 6bb6da3ec173 by Alan Mackenzie <acm@muc.de> in
    May 24 2006, but that was reverted by Paul Eggert's commit
    dff4f9c759f5 on Sep 18 2019.
    
    * lisp/startup.el (command-line): Don't `file-truename` `lisp-directory`.
    * src/lread.c (syms_of_lread) <load-history>: Adjust docstring,
    to reflect the fact that the files there aren't "true names".
    
    * doc/lispref/loading.texi (Hooks for Loading): Adjust accordingly.
    Also massage the text to reflect the fact that nowadays features are
    more common than file names as arguments to `with-eval-after-load`.

diff --git a/doc/lispref/loading.texi b/doc/lispref/loading.texi
index f6a3a0e2c26..acbe98ed84c 100644
--- a/doc/lispref/loading.texi
+++ b/doc/lispref/loading.texi
@@ -1320,6 +1320,11 @@ This macro arranges to evaluate @var{body} at the end of loading
 the file @var{library}, each time @var{library} is loaded.  If
 @var{library} is already loaded, it evaluates @var{body} right away.
 
+Usually @var{library} is a feature (i.e., a symbol), in which case
+@var{body} is evaluated at the end of any file where
+@code{(provide @var{library})} is called.
+
+@var{library} can be also a file name (i.e., a string).
 You don't need to give a directory or extension in the file name
 @var{library}.  Normally, you just give a bare file name, like this:
 
@@ -1329,8 +1334,8 @@ You don't need to give a directory or extension in the file name
 
 To restrict which files can trigger the evaluation, include a
 directory or an extension or both in @var{library}.  Only a file whose
-absolute true name (i.e., the name with all symbolic links chased out)
-matches all the given name components will match.  In the following
+absolute name matches all the given name components will match.
+In the following
 example, @file{my_inst.elc} or @file{my_inst.elc.gz} in some directory
 @code{..../foo/bar} will trigger the evaluation, but not
 @file{my_inst.el}:
@@ -1339,10 +1344,6 @@ example, @file{my_inst.elc} or @file{my_inst.elc.gz} in some directory
 (with-eval-after-load "foo/bar/my_inst.elc" @dots{})
 @end example
 
-@var{library} can also be a feature (i.e., a symbol), in which case
-@var{body} is evaluated at the end of any file where
-@code{(provide @var{library})} is called.
-
 An error in @var{body} does not undo the load, but does prevent
 execution of the rest of @var{body}.
 @end defmac
diff --git a/lisp/startup.el b/lisp/startup.el
index 836ead6deb0..aab8fcfe9f2 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -1237,8 +1237,7 @@ please check its value")
 	  (unless (file-readable-p lispdir)
 	    (princ (format "Lisp directory %s not readable?" lispdir))
 	    (terpri)))
-      (setq lisp-directory
-            (file-truename (file-name-directory simple-file-name)))
+      (setq lisp-directory (file-name-directory simple-file-name))
       (setq load-history
 	    (mapcar (lambda (elt)
 		      (if (and (stringp (car elt))
diff --git a/src/lread.c b/src/lread.c
index 273957507a3..9c4da863363 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -5686,7 +5686,7 @@ the rest of the FUNCS.  */);
 	       doc: /* Alist mapping loaded file names to symbols and features.
 Each alist element should be a list (FILE-NAME ENTRIES...), where
 FILE-NAME is the name of a file that has been loaded into Emacs.
-The file name is absolute and true (i.e. it doesn't contain symlinks).
+The file name is absolute.
 As an exception, one of the alist elements may have FILE-NAME nil,
 for symbols and features not associated with any file.
 

commit b34040302f98fabe132e2ae3b383d6e903dacdfd
Author: Juri Linkov <juri@linkov.net>
Date:   Wed Nov 5 19:54:56 2025 +0200

    * lisp/image.el (image-supported-file-p): Fix autoload cookie (bug#79764).
    
    * lisp/emacs-lisp/icons.el (icons--create):
    * lisp/mail/rmailmm.el (rmail-mime-set-bulk-data):
    Remove unnecessary '(fboundp 'image-supported-file-p)'.

diff --git a/lisp/emacs-lisp/icons.el b/lisp/emacs-lisp/icons.el
index 83bbfc10cb4..b01cc76275e 100644
--- a/lisp/emacs-lisp/icons.el
+++ b/lisp/emacs-lisp/icons.el
@@ -194,7 +194,6 @@ present if the icon is represented by an image."
          (file-exists (and (stringp file) (file-readable-p file))))
     (and file-exists
          (display-images-p)
-         (fboundp 'image-supported-file-p)
          (image-supported-file-p file)
          (propertize
           " " 'display
diff --git a/lisp/image.el b/lisp/image.el
index 51a7a687961..06cd1543c08 100644
--- a/lisp/image.el
+++ b/lisp/image.el
@@ -417,7 +417,7 @@ be determined."
 	    ;; If nothing seems to be supported, return first type that matched.
 	    (or first (setq first type))))))))
 
- ;;;###autoload
+;;;###autoload
 (defun image-supported-file-p (file)
   "Return non-nil if Emacs can display the specified image FILE.
 The returned value is a symbol specifying the image type of FILE,
diff --git a/lisp/mail/rmailmm.el b/lisp/mail/rmailmm.el
index 173f95fd325..a1fb715ab5e 100644
--- a/lisp/mail/rmailmm.el
+++ b/lisp/mail/rmailmm.el
@@ -842,9 +842,8 @@ directly."
      ((string-match "text/" content-type)
       (setq type 'text))
      ((string-match "image/\\(.*\\)" content-type)
-      (setq type (and (fboundp 'image-supported-file-p)
-                      (image-supported-file-p
-		       (concat "." (match-string 1 content-type)))))
+      (setq type (image-supported-file-p
+		  (concat "." (match-string 1 content-type))))
       (when (and type
                  rmail-mime-show-images
 	         (not (eq rmail-mime-show-images 'button))

commit 9e905357bb5da9c0d54ec9d8a708ff0ac0411a09
Merge: eb813185265 78bcd4394cc
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Wed Nov 5 18:57:27 2025 +0200

    Merge branch 'master' of git.savannah.gnu.org:/srv/git/emacs

commit eb81318526508bab655248f05246d1eb8551cac0
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Wed Nov 5 18:56:41 2025 +0200

    ; * doc/emacs/help.texi (Misc Help): Improve and extend wording.

diff --git a/doc/emacs/help.texi b/doc/emacs/help.texi
index 879967ddfb2..b2cd7f19e71 100644
--- a/doc/emacs/help.texi
+++ b/doc/emacs/help.texi
@@ -720,10 +720,13 @@ If you see commands that you are not familiar with, use
 @kbd{C-h k}, or press @kbd{RET} or click on them to find out what they do.
 
 @vindex view-lossage-auto-refresh
-By default, after the lossage buffer is displayed it will not show the
-most recent keystroke and command that you are currently typing, to
-change this set the variable @code{view-lossage-auto-refresh} to
-@code{t}.
+By default, once the lossage buffer is displayed, it will not show the
+keystroke and commands you will type after displaying it.  But if you
+set the variable @code{view-lossage-auto-refresh} to the value @code{t},
+the lossage buffer will be continuously refreshed as you type further
+commands.  Alternatively, you can invoke @code{view-lossage} with a
+prefix argument, as in @kbd{C-u C-h l}, to display the lossage buffer
+and have it auto-refresh thereafter.
 
 @kindex C-h e
 @findex view-echo-area-messages

commit 78bcd4394cca61f2b19a710b293100211a306f97
Author: Sean Whitton <spwhitton@spwhitton.name>
Date:   Wed Nov 5 16:49:18 2025 +0000

    ; * lisp/subr.el (if-let*): Use "Lisp programmers".

diff --git a/lisp/subr.el b/lisp/subr.el
index 8f414c92a46..1ed57765b12 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2830,7 +2830,7 @@ binding of SYMBOL is checked for nil, only.
 
 An older form for entries of VARLIST is also supported, where SYMBOL is
 omitted, i.e. (VALUEFORM).  This means the same as (_ VALUEFORM).
-This form is not recommended because many programmers find it
+This form is not recommended because many Lisp programmers find it
 significantly less readable.  A future release of Emacs may introduce a
 byte-compiler warning for uses of (VALUEFORM) in VARLIST."
   (declare (indent 2)

commit 8815194ea6d4d0fbbe7967c5e3b08526ef032337
Author: Mattias Engdegård <mattias.engdegard@gmail.com>
Date:   Sun Nov 2 10:20:47 2025 +0100

    Unify constants that are equal-including-properties in compiler
    
    This results in a healthy reduction of .elc file size (> 300 KiB saved)
    as well as less memory use.
    
    * lisp/emacs-lisp/bytecomp.el (byte-compile-get-constant):
    Use 'equal-including-properties' as equivalence relation for all
    constants, not just strings.
    * etc/NEWS: Mention it.  Strictly speaking it's not an incompatible
    change because it doesn't break any earlier promises, but for people
    having code that made incorrect assumptions, this provides a useful
    explanation.

diff --git a/etc/NEWS b/etc/NEWS
index 7345c08218b..ed504118e66 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -3049,6 +3049,16 @@ Other functions that use 'aset' to modify string data, such as
 'subst-char-in-string' with a non-nil INPLACE argument, will signal an
 error if called with arguments that would violate these rules.
 
++++
+** More program constants are combined by the compiler.
+The compiler now unifies more constants that are 'equal' for better code
+generation.  This does not affect correct programs but may expose some
+coding mistakes.  For example,
+
+    (eq (cdr '(1 2 3)) '(2 3)))
+
+may return either nil or t.
+
 ** Nested backquotes are not supported any more in Pcase patterns.
 
 ---
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index bf3d80f2d80..b5b371f7833 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -3870,8 +3870,7 @@ assignment (i.e. `setq')."
       (byte-compile-dynamic-variable-op 'byte-varset var))))
 
 (defmacro byte-compile-get-constant (const)
-  `(or (assoc ,const byte-compile-constants
-              (if (stringp ,const) #'equal-including-properties #'eql))
+  `(or (assoc ,const byte-compile-constants #'equal-including-properties)
        (car (setq byte-compile-constants
 		  (cons (list ,const) byte-compile-constants)))))
 

commit ef1dfdc66330305cfb52420e0e754248d581ede3
Author: Sean Whitton <spwhitton@spwhitton.name>
Date:   Wed Nov 5 16:07:56 2025 +0000

    Further document cond*'s bind-and*, document cond-let* discussion
    
    * doc/lispref/control.texi (Conditionals): Pointer to cond*'s
    bind-and* clauses for Lisp programmers looking for a cond-let*.
    (cond* Macro): Document bind-and* clauses.
    * lisp/subr.el: Comment summarizing recent discussion, for
    future Emacs developers wondering about cond-let*.

diff --git a/doc/lispref/control.texi b/doc/lispref/control.texi
index fc0a56ee6d5..b7b2d40caee 100644
--- a/doc/lispref/control.texi
+++ b/doc/lispref/control.texi
@@ -317,8 +317,8 @@ following way instead:
   (do-something result2))
 @end example
 
-There's a number of variations on this theme, and they're briefly
-described below.
+There's a number of variations on this theme, and they're described
+below.
 
 @defmac if-let* varlist then-form else-forms...
 Evaluate each binding in @var{varlist}, stopping if a binding value is
@@ -376,6 +376,22 @@ Some Lisp programmers follow the convention that @code{and} and
 @code{when} and @code{when-let*} are for forms evaluated for side-effect
 with returned values ignored.
 
+There is no @code{cond-let*} macro because extending the structure
+shared by @code{if-let*}, @code{when-let*} and @code{and-let*} to the
+case of @code{cond} is not simple.@footnote{The problem is that there
+are multiple ways to do it that are all useful but not compatible.  In
+addition, the resulting macro is complicated, and so tricky to learn how
+to read and write.}  However, you can use the @code{cond*} macro's
+@code{bind-and*} clauses (@pxref{cond* Macro}) to achieve something
+similar:
+
+@example
+(cond* ((bind-and* (result1 (do-computation))
+                   (result2 (do-more result1)))
+        (do-something result2))
+       ...)
+@end example
+
 A similar macro exists to run a loop until one binding evaluates to
 @code{nil}:
 
@@ -1503,6 +1519,14 @@ the bindings list in @code{let*}, @pxref{Local Variables}) for the body
 of the clause, and all subsequent clauses.  As a condition, it counts as
 true if the first binding's value is non-@code{nil}.
 
+@findex bind-and*
+@code{(bind-and* @var{bindings}@dots{})} means to bind @var{bindings}
+(like the bindings list in @code{if-let*}, @pxref{Conditionals}) for
+only the body of the clause.  As a condition, it counts as true if none
+of the bindings evaluate to @code{nil}.  In addition, if any binding
+evaluates to @code{nil}, the expressions for the values of subsequent
+bindings are not evaluated.
+
 @findex match*
 @findex pcase*
 @code{(match* @var{pattern} @var{datum})} means to match @var{datum}
diff --git a/lisp/subr.el b/lisp/subr.el
index a5f8ead0a1b..8f414c92a46 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2756,7 +2756,34 @@ Affects only hooks run in the current buffer."
      (let ((delay-mode-hooks t))
        ,@body)))
 
-;;; `when-let' and friends.
+;;; `if-let*' and friends.
+;;;
+;;; We considered adding a `cond-let*' in late 2025:
+;;; <https://lists.gnu.org/archive/html/emacs-devel/2025-09/msg00058.html>.
+;;; We decided to add the `bind-and*' clause type to `cond*' instead.
+;;; At first it seems simple to extend `if-let*'/`when-let*'/`and-let*'
+;;; to `cond', but the extension is not unambiguous: there are multiple
+;;; useful, incompatible ways to do it.
+;;; In particular, it quickly becomes clear that one wants clauses that
+;;; only establish bindings for proceeding clauses, instead of exiting
+;;; the `cond-let*'.  But then
+;;; - Should these bindings be just like in `let*', or like in
+;;;   `if-let*'?  In other words, should it be that if a binding
+;;;   evaluates to nil we skip the remaining bindings (bind them all to
+;;;   nil)?  Both ways of doing it seem useful.
+;;; - The parentheses quickly pile up.  How can we avoid the programmer
+;;;   having to count parentheses?  Some propose using square brackets
+;;;   (i.e., vectors) for the binding-only clauses, but Emacs Lisp is a
+;;;   traditional Lisp which uses exclusively parentheses for control
+;;;   constructs.  Therefore, introducing square brackets here would be
+;;;   jarring to read.  Another option would be to use symbols at the
+;;;   beginning of clauses, like `cond*' does.
+;;; Whichever way one goes, the resulting macro ends up complicated,
+;;; with a substantial learning burden.  Adding `bind-and*' clauses to
+;;; `cond*' gives us the desired functionality, and does not make
+;;; `cond*' much more complicated.  In other words, `cond*' is already
+;;; complicated, and one complicated `cond'-extending macro is better
+;;; than two.  --spwhitton
 
 (defun internal--build-binding (binding prev-var)
   "Check and build a single BINDING with PREV-VAR."

commit d3101630abfaff68990a99ebccb3f767550f16a6
Author: Eli Zaretskii <eliz@gnu.org>
Date:   Wed Nov 5 17:51:42 2025 +0200

    Unbreak MinGW build broken by Gnulib merge
    
    * lib/acl_entries.c (acl_entries): Make it no-op for MinGW, as it
    was before.  Without this, acl_entries doesn't compile on MinGW.
    
    * nt/gnulib-cfg.mk (OMIT_GNULIB_MODULE_issymlink)
    (OMIT_GNULIB_MODULE_issymlinkat): Disable these Gnulib modules.

diff --git a/lib/acl_entries.c b/lib/acl_entries.c
index b78ba18a656..f9619c0f539 100644
--- a/lib/acl_entries.c
+++ b/lib/acl_entries.c
@@ -44,7 +44,7 @@ acl_entries (acl_t acl)
            got_one >= 0;
            got_one = acl_get_entry (acl, ACL_NEXT_ENTRY, &ace))
         count++;
-#else /* Linux, FreeBSD, NetBSD >= 10, Cygwin >= 2.5 */
+#elif !defined __MINGW32__ /* Linux, FreeBSD, NetBSD >= 10, Cygwin >= 2.5 */
       /* acl_get_entry returns 1 when it successfully fetches an entry,
          and 0 at the end.  */
       acl_entry_t ace;
diff --git a/nt/gnulib-cfg.mk b/nt/gnulib-cfg.mk
index 7b164c1b119..d2f09cf095e 100644
--- a/nt/gnulib-cfg.mk
+++ b/nt/gnulib-cfg.mk
@@ -59,6 +59,8 @@ OMIT_GNULIB_MODULE_futimens = true
 OMIT_GNULIB_MODULE_getdelim = true
 OMIT_GNULIB_MODULE_getline = true
 OMIT_GNULIB_MODULE_inttypes-h-incomplete = true
+OMIT_GNULIB_MODULE_issymlink = true
+OMIT_GNULIB_MODULE_issymlinkat = true
 OMIT_GNULIB_MODULE_lchmod = true
 OMIT_GNULIB_MODULE_malloc-gnu = true
 OMIT_GNULIB_MODULE_malloc-posix = true