bug#63708: 29.0.60; rust-ts-mode not properly handling apostrophe

[yordanm--- via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>]

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

And here's the patch...

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Fix-apostrophe-handling-in-rust-ts-mode.patch --]
[-- Type: text/x-patch; name=0001-Fix-apostrophe-handling-in-rust-ts-mode.patch, Size: 4933 bytes --]

From e9a03ce475b358d9004aa73a6640327c72855e4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=99=D0=BE=D1=80=D0=B4=D0=B0=D0=BD=20=D0=9C=D0=B8=D0=BB?=
 =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D0=BD=D0=BE=D0=B2?= <yordanm@pm.me>
Date: Fri, 26 May 2023 17:23:26 +0300
Subject: [PATCH] Fix apostrophe handling in rust-ts-mode

* lisp/progmodes/rust-ts-mode.el (rust-ts-mode--syntax-propertize)

  Treat apostrophes as strings if used to define character literals.

  Treat LT and GT as pairs if used to define type parameters (formerly
  they were treated as pairs only for type arguments).

* lisp/progmodes/go-ts-mode.el (go-ts-mode)

  Treat apostrophes as strings if used to define rune literals.
---
 lisp/progmodes/go-ts-mode.el   | 20 +++++++++++++++
 lisp/progmodes/rust-ts-mode.el | 47 ++++++++++++++++++++++------------
 2 files changed, 51 insertions(+), 16 deletions(-)

diff --git a/lisp/progmodes/go-ts-mode.el b/lisp/progmodes/go-ts-mode.el
index b8705ecc4d0..ec1edd46122 100644
--- a/lisp/progmodes/go-ts-mode.el
+++ b/lisp/progmodes/go-ts-mode.el
@@ -209,6 +209,22 @@ go-ts-mode-map
   :parent prog-mode-map
   "C-c C-d" #'go-ts-mode-docstring)
 
+(defun go-ts-mode--syntax-propertize (beg end)
+    "Apply syntax properties to various special characters with
+contextual meaning between BEG and END.
+
+Apostrophes (') are commonly treated as punctuation, but when
+used to define rune literals, they should be treated as strings."
+  (goto-char beg)
+  (while (search-forward "'" end t)
+    (when (string-equal "rune_literal"
+                        (treesit-node-type
+                         (treesit-node-at (match-beginning 0))))
+      (put-text-property (match-beginning 0)
+                         (match-end 0)
+                         'syntax-table
+                         '(7)))))
+
 ;;;###autoload
 (define-derived-mode go-ts-mode prog-mode "Go"
   "Major mode for editing Go, powered by tree-sitter.
@@ -220,6 +236,10 @@ go-ts-mode
   (when (treesit-ready-p 'go)
     (treesit-parser-create 'go)
 
+    ;; Syntax.
+    (setq-local syntax-propertize-function
+                #'go-ts-mode--syntax-propertize)
+
     ;; Comments.
     (setq-local comment-start "// ")
     (setq-local comment-end "")
diff --git a/lisp/progmodes/rust-ts-mode.el b/lisp/progmodes/rust-ts-mode.el
index be06acde3e3..faae9e6434c 100644
--- a/lisp/progmodes/rust-ts-mode.el
+++ b/lisp/progmodes/rust-ts-mode.el
@@ -350,26 +350,41 @@ rust-ts-mode--defun-name
       (treesit-node-child-by-field-name node "name") t))))
 
 (defun rust-ts-mode--syntax-propertize (beg end)
-  "Apply syntax text property to template delimiters between BEG and END.
+  "Apply syntax properties to various special characters with
+contextual meaning between BEG and END.
 
-< and > are usually punctuation, e.g., as greater/less-than.  But
-when used for types, they should be considered pairs.
+Apostrophes (') are commonly treated as punctuation, but when
+used to define character literals, they should be treated as
+strings.
 
-This function checks for < and > in the changed RANGES and apply
-appropriate text property to alter the syntax of template
-delimiters < and >'s."
+Less-than and greater-than (<>) are usually punctuation, but when
+used for type parameters, they should be considered pairs.
+
+This function scans the changed RANGES for these special
+characters and applies the appropriate text properties to reflect
+their syntactical meaning."
+  (goto-char beg)
+  (while (search-forward "'" end t)
+    (when (string-equal "char_literal"
+                        (treesit-node-type
+                         (treesit-node-at (match-beginning 0))))
+      (put-text-property (match-beginning 0)
+                         (match-end 0)
+                         'syntax-table
+                         '(7))))
   (goto-char beg)
   (while (re-search-forward (rx (or "<" ">")) end t)
-    (pcase (treesit-node-type
-            (treesit-node-parent
-             (treesit-node-at (match-beginning 0))))
-      ("type_arguments"
-       (put-text-property (match-beginning 0)
-                          (match-end 0)
-                          'syntax-table
-                          (pcase (char-before)
-                            (?< '(4 . ?>))
-                            (?> '(5 . ?<))))))))
+    (let ((parent-type (treesit-node-type
+                        (treesit-node-parent
+                         (treesit-node-at (match-beginning 0))))))
+      (when (or (string-equal parent-type "type_arguments")
+                (string-equal parent-type "type_parameters"))
+        (put-text-property (match-beginning 0)
+                           (match-end 0)
+                           'syntax-table
+                           (pcase (char-before)
+                             (?< '(4 . ?>))
+                             (?> '(5 . ?<))))))))
 
 ;;;###autoload
 (define-derived-mode rust-ts-mode prog-mode "Rust"
-- 
2.40.1