Silence byte-compile warnings when treesit is not available

* lisp/progmodes/c-ts-mode.el:
* lisp/progmodes/cmake-ts-mode.el:
* lisp/progmodes/csharp-mode.el:
* lisp/progmodes/dockerfile-ts-mode.el:
* lisp/progmodes/elixir-ts-mode.el:
* lisp/progmodes/go-ts-mode.el:
* lisp/progmodes/heex-ts-mode.el:
* lisp/progmodes/java-ts-mode.el:
* lisp/progmodes/js.el:
* lisp/progmodes/json-ts-mode.el:
* lisp/progmodes/lua-ts-mode.el:
* lisp/progmodes/php-ts-mode.el:
* lisp/progmodes/ruby-ts-mode.el:
* lisp/progmodes/rust-ts-mode.el:
* lisp/progmodes/sh-script.el:
* lisp/progmodes/typescript-ts-mode.el:
* lisp/textmodes/css-mode.el:
* lisp/textmodes/markdown-ts-mode.el:
* lisp/textmodes/mhtml-ts-mode.el:
* lisp/textmodes/toml-ts-mode.el:
* lisp/textmodes/yaml-ts-mode.el:
Declare 'treesit-major-mode-remap-alist' and
'treesit-language-available-p' to silence warnings
that are false alarms.  Also improve docstrings.

lisp/progmodes/c-ts-mode.el

@@ -1675,6 +1675,7 @@ the code is C or C++, and based on that chooses whether to enable
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(c-mode . c-ts-mode))
   (add-to-list 'treesit-major-mode-remap-alist

lisp/progmodes/cmake-ts-mode.el

@@ -257,7 +257,10 @@ Return nil if there is no name or if NODE is not a defun node."
 
 ;;;###autoload
 (defun cmake-ts-mode-maybe ()
-  "Enable `cmake-ts-mode' when its grammar is available."
+  "Enable `cmake-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'cmake)
           (eq treesit-enabled-modes t)
           (memq 'cmake-ts-mode treesit-enabled-modes))
@@ -269,6 +272,7 @@ Return nil if there is no name or if NODE is not a defun node."
   (add-to-list 'auto-mode-alist
                '("\\(?:CMakeLists\\.txt\\|\\.cmake\\)\\'" . cmake-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(cmake-mode . cmake-ts-mode)))
 

lisp/progmodes/csharp-mode.el

@@ -1225,6 +1225,7 @@ Key bindings:
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(csharp-mode . csharp-ts-mode)))
 

lisp/progmodes/dockerfile-ts-mode.el

@@ -204,7 +204,10 @@ Return nil if there is no name or if NODE is not a stage node."
 
 ;;;###autoload
 (defun dockerfile-ts-mode-maybe ()
-  "Enable `dockerfile-ts-mode' when its grammar is available."
+  "Enable `dockerfile-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'dockerfile)
           (eq treesit-enabled-modes t)
           (memq 'dockerfile-ts-mode treesit-enabled-modes))
@@ -218,6 +221,7 @@ Return nil if there is no name or if NODE is not a stage node."
                '("\\(?:Dockerfile\\(?:\\..*\\)?\\|\\.[Dd]ockerfile\\)\\'"
                  . dockerfile-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(dockerfile-mode . dockerfile-ts-mode)))
 

lisp/progmodes/elixir-ts-mode.el

@@ -808,7 +808,10 @@ Return nil if NODE is not a defun node or doesn't have a name."
 
 ;;;###autoload
 (defun elixir-ts-mode-maybe ()
-  "Enable `elixir-ts-mode' when its grammar is available."
+  "Enable `elixir-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'elixir)
           (eq treesit-enabled-modes t)
           (memq 'elixir-ts-mode treesit-enabled-modes))
@@ -822,6 +825,7 @@ Return nil if NODE is not a defun node or doesn't have a name."
   (add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-ts-mode-maybe))
   (add-to-list 'auto-mode-alist '("mix\\.lock" . elixir-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(elixir-mode . elixir-ts-mode)))
 

lisp/progmodes/go-ts-mode.el

@@ -361,7 +361,10 @@
 
 ;;;###autoload
 (defun go-ts-mode-maybe ()
-  "Enable `go-ts-mode' when its grammar is available."
+  "Enable `go-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'go)
           (eq treesit-enabled-modes t)
           (memq 'go-ts-mode treesit-enabled-modes))
@@ -372,6 +375,7 @@
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.go\\'" . go-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(go-mode . go-ts-mode)))
 
@@ -635,7 +639,10 @@ what the parent of the node would be if it were a node."
 
 ;;;###autoload
 (defun go-mod-ts-mode-maybe ()
-  "Enable `go-mod-ts-mode' when its grammar is available."
+  "Enable `go-mod-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'gomod)
           (eq treesit-enabled-modes t)
           (memq 'go-mod-ts-mode treesit-enabled-modes))
@@ -646,6 +653,7 @@ what the parent of the node would be if it were a node."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("/go\\.mod\\'" . go-mod-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(go-mod-mode . go-mod-ts-mode)))
 
@@ -736,7 +744,10 @@ what the parent of the node would be if it were a node."
 
 ;;;###autoload
 (defun go-work-ts-mode-maybe ()
-  "Enable `go-work-ts-mode' when its grammar is available."
+  "Enable `go-work-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'gowork)
           (eq treesit-enabled-modes t)
           (memq 'go-work-ts-mode treesit-enabled-modes))
@@ -747,6 +758,7 @@ what the parent of the node would be if it were a node."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("/go\\.work\\'" . go-work-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(go-work-mode . go-work-ts-mode)))
 

lisp/progmodes/heex-ts-mode.el

@@ -267,7 +267,10 @@ Return nil if NODE is not a defun node or doesn't have a name."
 
 ;;;###autoload
 (defun heex-ts-mode-maybe ()
-  "Enable `heex-ts-mode' when its grammar is available."
+  "Enable `heex-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'heex)
           (eq treesit-enabled-modes t)
           (memq 'heex-ts-mode treesit-enabled-modes))
@@ -280,6 +283,7 @@ Return nil if NODE is not a defun node or doesn't have a name."
   ;; with the tree-sitter-heex grammar.
   (add-to-list 'auto-mode-alist '("\\.[hl]?eex\\'" . heex-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(heex-mode . heex-ts-mode)))
 

lisp/progmodes/java-ts-mode.el

@@ -526,6 +526,7 @@ Return nil if there is no name or if NODE is not a defun node."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(java-mode . java-ts-mode)))
 

lisp/progmodes/js.el

@@ -4111,6 +4111,7 @@ See `treesit-thing-settings' for more information.")
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(javascript-mode . js-ts-mode)))
 

lisp/progmodes/json-ts-mode.el

@@ -183,6 +183,7 @@ Return nil if there is no name or if NODE is not a defun node."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(js-json-mode . json-ts-mode)))
 

lisp/progmodes/lua-ts-mode.el

@@ -771,7 +771,10 @@ Calls REPORT-FN directly."
 
 ;;;###autoload
 (defun lua-ts-mode-maybe ()
-  "Enable `lua-ts-mode' when its grammar is available."
+  "Enable `lua-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'lua)
           (eq treesit-enabled-modes t)
           (memq 'lua-ts-mode treesit-enabled-modes))
@@ -783,6 +786,7 @@ Calls REPORT-FN directly."
   (add-to-list 'auto-mode-alist '("\\.lua\\'" . lua-ts-mode-maybe))
   (add-to-list 'interpreter-mode-alist '("\\<lua\\(?:jit\\)?" . lua-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(lua-mode . lua-ts-mode)))
 

lisp/progmodes/php-ts-mode.el

@@ -1924,7 +1924,10 @@ file to use."
 
 ;;;###autoload
 (defun php-ts-mode-maybe ()
-  "Enable `php-ts-mode' when its grammar is available."
+  "Enable `php-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'php)
           (eq treesit-enabled-modes t)
           (memq 'php-ts-mode treesit-enabled-modes))
@@ -1943,6 +1946,7 @@ file to use."
    'interpreter-mode-alist
    (cons "php\\(?:-?[34578]\\(?:\\.[0-9]+\\)*\\)?" 'php-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(php-mode . php-ts-mode)))
 

lisp/progmodes/ruby-ts-mode.el

@@ -1279,6 +1279,7 @@ leading double colon is not added."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(ruby-mode . ruby-ts-mode)))
 

lisp/progmodes/rust-ts-mode.el

@@ -656,7 +656,10 @@ See `prettify-symbols-compose-predicate'."
 
 ;;;###autoload
 (defun rust-ts-mode-maybe ()
-  "Enable `rust-ts-mode' when its grammar is available."
+  "Enable `rust-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'rust)
           (eq treesit-enabled-modes t)
           (memq 'rust-ts-mode treesit-enabled-modes))
@@ -667,6 +670,7 @@ See `prettify-symbols-compose-predicate'."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(rust-mode . rust-ts-mode)))
 

lisp/progmodes/sh-script.el

@@ -1650,6 +1650,7 @@ not written in Bash or sh."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(sh-mode . bash-ts-mode)))
 

lisp/progmodes/typescript-ts-mode.el

@@ -724,7 +724,10 @@ This mode is intended to be inherited by concrete major modes."
 
 ;;;###autoload
 (defun typescript-ts-mode-maybe ()
-  "Enable `typescript-ts-mode' when its grammar is available."
+  "Enable `typescript-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'typescript)
           (eq treesit-enabled-modes t)
           (memq 'typescript-ts-mode treesit-enabled-modes))
@@ -735,6 +738,7 @@ This mode is intended to be inherited by concrete major modes."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(typescript-mode . typescript-ts-mode)))
 
@@ -857,7 +861,10 @@ at least 3 (which is the default value)."
 
 ;;;###autoload
 (defun tsx-ts-mode-maybe ()
-  "Enable `tsx-ts-mode' when its grammar is available."
+  "Enable `tsx-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'tsx)
           (eq treesit-enabled-modes t)
           (memq 'tsx-ts-mode treesit-enabled-modes))
@@ -868,6 +875,7 @@ at least 3 (which is the default value)."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.tsx\\'" . tsx-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(tsx-mode . tsx-ts-mode)))
 

lisp/textmodes/css-mode.el

@@ -1917,6 +1917,7 @@ can also be used to fill comments.
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(css-mode . css-ts-mode)))
 

lisp/textmodes/markdown-ts-mode.el

@@ -405,7 +405,10 @@ the same features enabled in MODE."
 
 ;;;###autoload
 (defun markdown-ts-mode-maybe ()
-  "Enable `markdown-ts-mode' when its grammar is available."
+  "Enable `markdown-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'markdown)
           (eq treesit-enabled-modes t)
           (memq 'markdown-ts-mode treesit-enabled-modes))
@@ -416,6 +419,7 @@ the same features enabled in MODE."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(markdown-mode . markdown-ts-mode)))
 

lisp/textmodes/mhtml-ts-mode.el

@@ -589,6 +589,7 @@ Powered by tree-sitter."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(mhtml-mode . mhtml-ts-mode)))
 

lisp/textmodes/toml-ts-mode.el

@@ -174,6 +174,7 @@ Return nil if there is no name or if NODE is not a defun node."
 
 ;;;###autoload
 (when (treesit-available-p)
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(conf-toml-mode . toml-ts-mode)))
 

lisp/textmodes/yaml-ts-mode.el

@@ -229,7 +229,10 @@ Return nil if there is no name or if NODE is not a defun node."
 
 ;;;###autoload
 (defun yaml-ts-mode-maybe ()
-  "Enable `yaml-ts-mode' when its grammar is available."
+  "Enable `yaml-ts-mode' when its grammar is available.
+Also propose to install the grammar when `treesit-enabled-modes'
+is t or contains the mode name."
+  (declare-function treesit-language-available-p "treesit.c")
   (if (or (treesit-language-available-p 'yaml)
           (eq treesit-enabled-modes t)
           (memq 'yaml-ts-mode treesit-enabled-modes))
@@ -240,6 +243,7 @@ Return nil if there is no name or if NODE is not a defun node."
 (when (treesit-available-p)
   (add-to-list 'auto-mode-alist '("\\.ya?ml\\'" . yaml-ts-mode-maybe))
   ;; To be able to toggle between an external package and core ts-mode:
+  (defvar treesit-major-mode-remap-alist)
   (add-to-list 'treesit-major-mode-remap-alist
                '(yaml-mode . yaml-ts-mode)))