Merge from savannah/emacs-30

ee3e3a63111 ; Update version number of exec/configure.ac
c5925b6ba5f Fix heex-ts-mode indentation following previews elixir-mo...
c3383be5f04 ; * admin/make-tarball.txt: Improve last change.
8ddb54117f1 ; * admin/make-tarball.txt: Remove now unnecessary config...
7e194d33f90 * lisp/ldefs-boot.el: Update.
9019536ea66 Fix use of Uniscribe font driver in MinGW build
5c55c860db7 Avoid crashes in redisplay in batch-mode testing
ba2190e1ae7 ; * etc/NEWS: Fix indentation.
818c0cc9a51 eglot-test-rust-completion-exit-function: Fix failure in ...
f47297782bd ; * doc/lispref/searching.texi (Rx Notation): Simplify rx...
03e56981675 Clarify the semantics of 'string-pixel-width'
9f0603207b1 ; * src/treesit.c: Minor cleanups of recent changes.
e0d3f743957 * src/treesit.c (treesit_debug_print_parser_list): Fix fo...
bed38ded730 ; * src/treesit.c (treesit_debug_print_parser_list): Fix ...
18c6487dbd0 ; * src/treesit.c: Add a prototype so there's no warning ...
bf23382f1f2 Read more on each call to treesit's buffer reader
3435464452b Fix the range handling in treesit.c
3fcec09f754 Add debugging function for treesit.c
0fd259d166c Fix elixir-ts-mode's range query
2329b36b1fb ; project-files-relative-names: Update docstring (bug#72701)
e55e2e1c6ba Make json-serialize always return a unibyte string (bug#7...
89c99891b2b ; * doc/lispref/os.texi (Suspending Emacs): Fix last change.
4f044d0d3df ; Improve documentation of 'suspend-emacs'

6 files changed, 140 insertions, 47 deletions

diff --git a/src/json.c b/src/json.c
index eb2fa0472c8..282dca6e8ff 100644
--- a/src/json.c
+++ b/src/json.c
@@ -559,16 +559,6 @@ json_out_something (json_out_t *jo, Lisp_Object obj)
     wrong_type_argument (Qjson_value_p, obj);
 }
 
-static Lisp_Object
-json_out_to_string (json_out_t *jo)
-{
-  /* FIXME: should this be a unibyte or multibyte string?
-     Right now we make a multibyte string for test compatibility,
-     but we are really encoding so unibyte would make more sense.  */
-  ptrdiff_t nchars = jo->size - jo->chars_delta;
-  return make_multibyte_string (jo->buf, nchars, jo->size);
-}
-
 static void
 json_serialize (json_out_t *jo, Lisp_Object object,
                 ptrdiff_t nargs, Lisp_Object *args)
@@ -596,7 +586,7 @@ json_serialize (json_out_t *jo, Lisp_Object object,
 
 DEFUN ("json-serialize", Fjson_serialize, Sjson_serialize, 1, MANY,
        NULL,
-       doc: /* Return the JSON representation of OBJECT as a string.
+       doc: /* Return the JSON representation of OBJECT as a unibyte string.
 
 OBJECT is translated as follows:
 
@@ -629,7 +619,7 @@ usage: (json-serialize OBJECT &rest ARGS)  */)
   specpdl_ref count = SPECPDL_INDEX ();
   json_out_t jo;
   json_serialize (&jo, args[0], nargs - 1, args + 1);
-  return unbind_to (count, json_out_to_string (&jo));
+  return unbind_to (count, make_unibyte_string (jo.buf, jo.size));
 }
 
 DEFUN ("json-insert", Fjson_insert, Sjson_insert, 1, MANY,
diff --git a/src/keyboard.c b/src/keyboard.c
index 0992fab653b..6d28dca9aeb 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -11917,7 +11917,12 @@ Before suspending, run the normal hook `suspend-hook'.
 After resumption run the normal hook `suspend-resume-hook'.
 
 Some operating systems cannot stop the Emacs process and resume it later.
-On such systems, Emacs starts a subshell instead of suspending.  */)
+On such systems, Emacs starts a subshell instead of suspending.
+
+On some operating systems, stuffing characters into terminal input
+buffer requires special privileges or is not supported at all.
+On such systems, calling this function with non-nil STUFFSTRING might
+either signal an error or silently fail to stuff the characters.  */)
   (Lisp_Object stuffstring)
 {
   specpdl_ref count = SPECPDL_INDEX ();
diff --git a/src/treesit.c b/src/treesit.c
index 5aedca44489..0ba6c733d64 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -489,6 +489,56 @@ treesit_initialize (void)
 }
 
 
+/*** Debugging */
+
+void treesit_debug_print_parser_list (char *, Lisp_Object);
+
+void
+treesit_debug_print_parser_list (char *msg, Lisp_Object parser)
+{
+  struct buffer *buf = XBUFFER (XTS_PARSER (parser)->buffer);
+  char *buf_name = SSDATA (BVAR (buf, name));
+  printf ("%s (%s) [%s] <%s>: %ld(%ld)-(%ld)%ld {\n",
+          msg == NULL ? "" : msg,
+          SSDATA (SYMBOL_NAME (Vthis_command)),
+          SSDATA (SYMBOL_NAME (XTS_PARSER (parser)->language_symbol)),
+          buf_name, BUF_BEG (buf),
+          BUF_BEGV (buf), BUF_Z (buf), BUF_ZV (buf));
+  Lisp_Object tail = BVAR (buf, ts_parser_list);
+
+  FOR_EACH_TAIL (tail)
+    {
+      struct Lisp_TS_Parser *parser = XTS_PARSER (XCAR (tail));
+      printf ("[%s %s %s %ld-%ld T:%ld]\n", SSDATA (SYMBOL_NAME (parser->language_symbol)),
+              SSDATA (SYMBOL_NAME (parser->tag)),
+              parser->need_reparse ? "NEED-R" : "NONEED",
+              parser->visible_beg, parser->visible_end,
+              parser->timestamp);
+      /* Print ranges. */
+      uint32_t len;
+      const TSRange *ranges
+        = ts_parser_included_ranges (parser->parser, &len);
+
+      if (!(len == 1 && ranges[0].start_byte == 0 && ranges[0].end_byte == -1))
+        {
+          for (int idx = 0; idx < len; idx++)
+            {
+              TSRange range = ranges[idx];
+              printf (" [%"PRIu32", %"PRIu32")", range.start_byte, range.end_byte);
+
+              /* if (!parser->need_reparse) */
+              /*        { */
+              /*          eassert (BUF_BEGV_BYTE (buf) <= range.start_byte + parser->visible_beg); */
+              /*          eassert (range.end_byte + parser->visible_beg <= BUF_ZV_BYTE (buf)); */
+              /*        } */
+            }
+          printf ("\n");
+        }
+    }
+  printf ("}\n\n");
+}
+
+
 /*** Loading language library  */
 
 /* Translate a symbol treesit-<lang> to a C name treesit_<lang>.  */
@@ -1002,6 +1052,48 @@ treesit_sync_visible_region (Lisp_Object parser)
 
   XTS_PARSER (parser)->visible_beg = visible_beg;
   XTS_PARSER (parser)->visible_end = visible_end;
+
+  /* Fix ranges so that the ranges stays with in visible_end.  Here we
+     try to do minimal work so that the ranges is minimally correct such
+     that there's no OOB error.  Usually treesit-update-ranges should
+     update the parser with actually correct ranges.  */
+  if (NILP (XTS_PARSER (parser)->last_set_ranges)) return;
+  uint32_t len;
+  const TSRange *ranges
+    = ts_parser_included_ranges (XTS_PARSER (parser)->parser, &len);
+  /* We might need to discard some ranges that exceeds visible_end, in
+     that case, new_len is the length of the new ranges array (which
+     will be shorter than len).  */
+  uint32_t new_len = 0;
+  uint32_t new_end = 0;
+  for (int idx = 0; idx < len; idx++)
+    {
+      TSRange range = ranges[idx];
+      /* If this range starts after visible_end, we don't include this
+         range and the ranges after it in the new ranges.  */
+      if (range.start_byte + visible_beg >= visible_end)
+        break;
+      /* If this range's end is after visible_end, we don't include any
+         ranges after it, and changes the end of this range to
+         visible_end.  */
+      if (range.end_byte + visible_beg > visible_end)
+        {
+          new_end = visible_end - visible_beg;
+          new_len++;
+          break;
+        }
+      new_len++;
+    }
+  if (new_len != len || new_end != 0)
+    {
+      TSRange *new_ranges = xmalloc (sizeof (TSRange) * new_len);
+      memcpy (new_ranges, ranges, sizeof (TSRange) * new_len);
+      new_ranges[new_len - 1].end_byte = new_end;
+      /* TODO: What should we do if this fails?  */
+      ts_parser_set_included_ranges (XTS_PARSER (parser)->parser,
+                                     new_ranges, new_len);
+      xfree (new_ranges);
+    }
 }
 
 static void
@@ -1014,7 +1106,8 @@ treesit_check_buffer_size (struct buffer *buffer)
               make_fixnum (buffer_size_bytes));
 }
 
-static Lisp_Object treesit_make_ranges (const TSRange *, uint32_t, struct buffer *);
+static Lisp_Object treesit_make_ranges (const TSRange *, uint32_t,
+                                        Lisp_Object, struct buffer *);
 
 static void
 treesit_call_after_change_functions (TSTree *old_tree, TSTree *new_tree,
@@ -1028,7 +1121,7 @@ treesit_call_after_change_functions (TSTree *old_tree, TSTree *new_tree,
     {
       uint32_t len;
       TSRange *ranges = ts_tree_get_changed_ranges (old_tree, new_tree, &len);
-      lisp_ranges = treesit_make_ranges (ranges, len, buf);
+      lisp_ranges = treesit_make_ranges (ranges, len, parser, buf);
       xfree (ranges);
     }
   else
@@ -1055,6 +1148,9 @@ treesit_call_after_change_functions (TSTree *old_tree, TSTree *new_tree,
 static void
 treesit_ensure_parsed (Lisp_Object parser)
 {
+  if (XTS_PARSER (parser)->within_reparse) return;
+  XTS_PARSER (parser)->within_reparse = true;
+
   struct buffer *buffer = XBUFFER (XTS_PARSER (parser)->buffer);
 
   /* Before we parse, catch up with the narrowing situation.  */
@@ -1063,10 +1159,11 @@ treesit_ensure_parsed (Lisp_Object parser)
      because it might set the flag to true.  */
   treesit_sync_visible_region (parser);
 
-  /* Make sure this comes before everything else, see comment
-     (ref:notifier-inside-ensure-parsed) for more detail.  */
   if (!XTS_PARSER (parser)->need_reparse)
-    return;
+    {
+      XTS_PARSER (parser)->within_reparse = false;
+      return;
+    }
 
   TSParser *treesit_parser = XTS_PARSER (parser)->parser;
   TSTree *tree = XTS_PARSER (parser)->tree;
@@ -1091,14 +1188,10 @@ treesit_ensure_parsed (Lisp_Object parser)
   XTS_PARSER (parser)->need_reparse = false;
   XTS_PARSER (parser)->timestamp++;
 
-  /* After-change functions should run at the very end, most crucially
-     after need_reparse is set to false, this way if the function
-     calls some tree-sitter function which invokes
-     treesit_ensure_parsed again, it returns early and do not
-     recursively call the after change functions again.
-     (ref:notifier-inside-ensure-parsed)  */
   treesit_call_after_change_functions (tree, new_tree, parser);
   ts_tree_delete (tree);
+
+  XTS_PARSER (parser)->within_reparse = false;
 }
 
 /* This is the read function provided to tree-sitter to read from a
@@ -1139,11 +1232,13 @@ treesit_read_buffer (void *parser, uint32_t byte_index,
       beg = NULL;
       len = 0;
     }
-  /* Normal case, read a character.  */
+  /* Normal case, read until the gap or visible end.  */
   else
     {
       beg = (char *) BUF_BYTE_ADDRESS (buffer, byte_pos);
-      len = BYTES_BY_CHAR_HEAD ((int) *beg);
+      ptrdiff_t gap_bytepos = BUF_GPT_BYTE (buffer);
+      len = (byte_pos < gap_bytepos)
+            ? gap_bytepos - byte_pos : visible_end - byte_pos;
     }
   /* We never let tree-sitter to parse buffers that large so this
      assertion should never hit.  */
@@ -1182,6 +1277,7 @@ make_treesit_parser (Lisp_Object buffer, TSParser *parser,
   lisp_parser->timestamp = 0;
   lisp_parser->deleted = false;
   lisp_parser->need_to_gc_buffer = false;
+  lisp_parser->within_reparse = false;
   eassert (lisp_parser->visible_beg <= lisp_parser->visible_end);
   return make_lisp_ptr (lisp_parser, Lisp_Vectorlike);
 }
@@ -1671,14 +1767,14 @@ treesit_check_range_argument (Lisp_Object ranges)
    convert between tree-sitter buffer offset and buffer position.  */
 static Lisp_Object
 treesit_make_ranges (const TSRange *ranges, uint32_t len,
-                     struct buffer *buffer)
+                     Lisp_Object parser, struct buffer *buffer)
 {
   Lisp_Object list = Qnil;
   for (int idx = 0; idx < len; idx++)
     {
       TSRange range = ranges[idx];
-      uint32_t beg_byte = range.start_byte + BUF_BEGV_BYTE (buffer);
-      uint32_t end_byte = range.end_byte + BUF_BEGV_BYTE (buffer);
+      uint32_t beg_byte = range.start_byte + XTS_PARSER (parser)->visible_beg;
+      uint32_t end_byte = range.end_byte + XTS_PARSER (parser)->visible_beg;
       eassert (BUF_BEGV_BYTE (buffer) <= beg_byte);
       eassert (beg_byte <= end_byte);
       eassert (end_byte <= BUF_ZV_BYTE (buffer));
@@ -1724,11 +1820,9 @@ buffer.  */)
   if (NILP (ranges))
     {
       /* If RANGES is nil, make parser to parse the whole document.
-         To do that we give tree-sitter a 0 length, the range is a
-         dummy.  */
-      TSRange treesit_range = {{0, 0}, {0, 0}, 0, 0};
+         To do that we give tree-sitter a 0 length.  */
       success = ts_parser_set_included_ranges (XTS_PARSER (parser)->parser,
-                                               &treesit_range , 0);
+                                               NULL , 0);
     }
   else
     {
@@ -1741,7 +1835,6 @@ buffer.  */)
 
       /* We can use XFIXNUM, XCAR, XCDR freely because we have checked
          the input by treesit_check_range_argument.  */
-
       for (int idx = 0; !NILP (ranges); idx++, ranges = XCDR (ranges))
         {
           Lisp_Object range = XCAR (ranges);
@@ -1786,6 +1879,10 @@ See also `treesit-parser-set-included-ranges'.  */)
   treesit_check_parser (parser);
   treesit_initialize ();
 
+  /* Our return value depends on the buffer state (BUF_BEGV_BYTE,
+     etc), so we need to sync up.  */
+  treesit_check_buffer_size (XBUFFER (XTS_PARSER (parser)->buffer));
+  treesit_sync_visible_region (parser);
   /* When the parser doesn't have a range set and we call
      ts_parser_included_ranges on it, it doesn't return an empty list,
      but rather return DEFAULT_RANGE.  (A single range where start_byte
@@ -1798,13 +1895,10 @@ See also `treesit-parser-set-included-ranges'.  */)
   const TSRange *ranges
     = ts_parser_included_ranges (XTS_PARSER (parser)->parser, &len);
 
-  /* Our return value depends on the buffer state (BUF_BEGV_BYTE,
-     etc), so we need to sync up.  */
-  treesit_check_buffer_size (XBUFFER (XTS_PARSER (parser)->buffer));
-  treesit_sync_visible_region (parser);
-
   struct buffer *buffer = XBUFFER (XTS_PARSER (parser)->buffer);
-  return treesit_make_ranges (ranges, len, buffer);
+
+
+  return treesit_make_ranges (ranges, len, parser, buffer);
 }
 
 DEFUN ("treesit-parser-notifiers", Ftreesit_parser_notifiers,
diff --git a/src/treesit.h b/src/treesit.h
index cd84fa358c5..40b8b531ac4 100644
--- a/src/treesit.h
+++ b/src/treesit.h
@@ -45,9 +45,12 @@ struct Lisp_TS_Parser
      same tag.  A tag is primarily used to differentiate between
      parsers for the same language.  */
   Lisp_Object tag;
-  /* The Lisp ranges last set.  This is use to compare to the new
-     ranges the users wants to set, and avoid reparse if the new
-     ranges is the same as the last set one.  */
+  /* The Lisp ranges last set.  This is use to compare to the new ranges
+     the users wants to set, and avoid reparse if the new ranges is the
+     same as the last set one.  This might go out of sync with the
+     ranges we return from Ftreesit_parser_included_ranges, if we did a
+     ranges fix in treesit_sync_visible_region, but I don't think
+     that'll cause any harm.  */
   Lisp_Object last_set_ranges;
   /* The buffer associated with this parser.  */
   Lisp_Object buffer;
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 751963705d2..b77bf56b8cf 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -1573,9 +1573,9 @@ syms_of_w32uniscribe_for_pdumper (void)
   pfnScriptGetGlyphABCWidth = &ScriptGetGlyphABCWidth;
   pfnScriptFreeCache = &ScriptFreeCache;
   pfnScriptGetCMap = &ScriptGetCMap;
+#endif /* Cygwin */
 
   uniscribe_available = 1;
-#endif /* Cygwin */
 
   register_font_driver (&uniscribe_font_driver, NULL);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 18834c6b781..7883c579815 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -11869,7 +11869,7 @@ window_text_pixel_size (Lisp_Object window, Lisp_Object from, Lisp_Object to,
 }
 
 DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 7, 0,
-       doc: /* Return the size of the text of WINDOW's buffer in pixels.
+       doc: /* Return the dimensions of the text of WINDOW's buffer in pixels.
 WINDOW must be a live window and defaults to the selected one.  The
 return value is a cons of the maximum pixel-width of any text line and
 the pixel-height of all the text lines in the accessible portion of
@@ -11949,7 +11949,7 @@ screen line that includes TO to the returned height of the text.  */)
 }
 
 DEFUN ("buffer-text-pixel-size", Fbuffer_text_pixel_size, Sbuffer_text_pixel_size, 0, 4, 0,
-       doc: /* Return size of whole text of BUFFER-OR-NAME in WINDOW.
+       doc: /* Return the dimensions of whole text of BUFFER-OR-NAME in WINDOW.
 BUFFER-OR-NAME must specify a live buffer or the name of a live buffer
 and defaults to the current buffer.  WINDOW must be a live window and
 defaults to the selected one.  The return value is a cons of the maximum
@@ -22182,7 +22182,8 @@ try_window_id (struct window *w)
 
   /* Window must either use window-based redisplay or be full width.  */
   if (!FRAME_WINDOW_P (f)
-      && (!FRAME_LINE_INS_DEL_OK (f)
+      && (FRAME_INITIAL_P (f)
+          || !FRAME_LINE_INS_DEL_OK (f)
           || !WINDOW_FULL_WIDTH_P (w)))
     GIVE_UP (4);