bug#32504: [PATCH] syntax-is-{comment|string}-p

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

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

Hello -

I got tired of checking/remembering whether (nth 3 (syntax-ppss)) was a
string or a comment, so I've created two simple functions that wrap that
in a more descriptive name. I've noticed that there are a handful of
these that other modes have written, so evidently others wanted them as
well at some point.

There are two patches attached. The first creates new functions
syntax-is-comment-p and syntax-is-string-p.

The second changes most of the uses of (nth 3 (syntax-ppss)) and (nth 4
(syntax-ppss)) to use these new functions. I'm attaching it as a
separate patch since I'm not sure if yall will want it or not; it's easy
to squash if you do.

Thanks,
Alex

------------------------------------------------------------

From 393f55de705513f5514a3e0250d81053e838c447 Mon Sep 17 00:00:00 2001
From: Alex Branham <alex.branham@gmail.com>
Date: Wed, 22 Aug 2018 14:44:26 -0500
Subject: [PATCH 1/2] Add new functions syntax-is-{comment|string}-p

* lisp/emacs-lisp/syntax.el (syntax-is-comment-p, syntax-is-string-p):
  New functions
* doc/lispref/syntax.texi: Add documentation for new functions
---
 doc/lispref/syntax.texi   | 10 ++++++++++
 etc/NEWS                  |  4 ++++
 lisp/emacs-lisp/syntax.el | 12 ++++++++++++
 3 files changed, 26 insertions(+)

diff --git a/doc/lispref/syntax.texi b/doc/lispref/syntax.texi
index dcfade3f67..e6220e5cf9 100644
--- a/doc/lispref/syntax.texi
+++ b/doc/lispref/syntax.texi
@@ -790,6 +790,16 @@ Position Parse
 Hooks}).
 @end defun
 
+@defun syntax-is-comment-p &optional pos
+This function returns non-nil when @code{POS} (which defaults to
+point) is in a comment accord to @code{syntax-ppss}
+@end defun
+
+@defun syntax-is-string-p &optional pos
+This function returns non-nil when @code{POS} (which defaults to
+point) is in a string accord to @code{syntax-ppss}
+@end defun
+
 @node Parser State
 @subsection Parser State
 @cindex parser state
diff --git a/etc/NEWS b/etc/NEWS
index d757f52466..e138105e72 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -963,6 +963,10 @@ versions.
 The new variable 'comment-use-syntax-ppss' can be set to nil to recover the old
 behavior if needed.
 
+** New functions 'syntax-is-comment-p' and 'syntax-is-string-p'.
+These can be used as a shorthand instead of checking, for example,
+(nth 3 (syntax-ppss)).
+
 ** The 'server-name' and 'server-socket-dir' variables are set when a
 socket has been passed to Emacs.
 
diff --git a/lisp/emacs-lisp/syntax.el b/lisp/emacs-lisp/syntax.el
index ad1a9665ff..2a262c6036 100644
--- a/lisp/emacs-lisp/syntax.el
+++ b/lisp/emacs-lisp/syntax.el
@@ -616,6 +616,18 @@ syntax-ppss
        ;; a nil state.
        (parse-partial-sexp (point-min) pos))))))
 
+(defun syntax-is-comment-p (&optional pos)
+  "Return non-nil if POS is inside a comment.
+POS defaults to `point'."
+  (let ((pos (or pos (point))))
+    (nth 4 (syntax-ppss pos))))
+
+(defun syntax-is-string-p (&optional pos)
+  "Return non-nil if POS is inside a string.
+POS defaults to `point'."
+  (let ((pos (or pos (point))))
+    (nth 3 (syntax-ppss pos))))
+
 ;; Debugging functions
 
 (defun syntax-ppss-debug ()
-- 
2.18.0




[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Add-new-functions-syntax-is-comment-string-p.patch --]
[-- Type: text/x-patch, Size: 2386 bytes --]

From 393f55de705513f5514a3e0250d81053e838c447 Mon Sep 17 00:00:00 2001
From: Alex Branham <alex.branham@gmail.com>
Date: Wed, 22 Aug 2018 14:44:26 -0500
Subject: [PATCH 1/2] Add new functions syntax-is-{comment|string}-p

* lisp/emacs-lisp/syntax.el (syntax-is-comment-p, syntax-is-string-p):
  New functions
* doc/lispref/syntax.texi: Add documentation for new functions
---
 doc/lispref/syntax.texi   | 10 ++++++++++
 etc/NEWS                  |  4 ++++
 lisp/emacs-lisp/syntax.el | 12 ++++++++++++
 3 files changed, 26 insertions(+)

diff --git a/doc/lispref/syntax.texi b/doc/lispref/syntax.texi
index dcfade3f67..e6220e5cf9 100644
--- a/doc/lispref/syntax.texi
+++ b/doc/lispref/syntax.texi
@@ -790,6 +790,16 @@ Position Parse
 Hooks}).
 @end defun
 
+@defun syntax-is-comment-p &optional pos
+This function returns non-nil when @code{POS} (which defaults to
+point) is in a comment accord to @code{syntax-ppss}
+@end defun
+
+@defun syntax-is-string-p &optional pos
+This function returns non-nil when @code{POS} (which defaults to
+point) is in a string accord to @code{syntax-ppss}
+@end defun
+
 @node Parser State
 @subsection Parser State
 @cindex parser state
diff --git a/etc/NEWS b/etc/NEWS
index d757f52466..e138105e72 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -963,6 +963,10 @@ versions.
 The new variable 'comment-use-syntax-ppss' can be set to nil to recover the old
 behavior if needed.
 
+** New functions 'syntax-is-comment-p' and 'syntax-is-string-p'.
+These can be used as a shorthand instead of checking, for example,
+(nth 3 (syntax-ppss)).
+
 ** The 'server-name' and 'server-socket-dir' variables are set when a
 socket has been passed to Emacs.
 
diff --git a/lisp/emacs-lisp/syntax.el b/lisp/emacs-lisp/syntax.el
index ad1a9665ff..2a262c6036 100644
--- a/lisp/emacs-lisp/syntax.el
+++ b/lisp/emacs-lisp/syntax.el
@@ -616,6 +616,18 @@ syntax-ppss
        ;; a nil state.
        (parse-partial-sexp (point-min) pos))))))
 
+(defun syntax-is-comment-p (&optional pos)
+  "Return non-nil if POS is inside a comment.
+POS defaults to `point'."
+  (let ((pos (or pos (point))))
+    (nth 4 (syntax-ppss pos))))
+
+(defun syntax-is-string-p (&optional pos)
+  "Return non-nil if POS is inside a string.
+POS defaults to `point'."
+  (let ((pos (or pos (point))))
+    (nth 3 (syntax-ppss pos))))
+
 ;; Debugging functions
 
 (defun syntax-ppss-debug ()
-- 
2.18.0


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #3: 0002-Prefer-using-new-syntax-is-comment-string-p-function.patch --]
[-- Type: text/x-patch, Size: 14711 bytes --]

From eff51e05fef4d452e52c81ed7259b51612d7917a Mon Sep 17 00:00:00 2001
From: Alex Branham <alex.branham@gmail.com>
Date: Wed, 22 Aug 2018 14:51:58 -0500
Subject: [PATCH 2/2] Prefer using new syntax-is-{comment|string}-p functions

* lisp/emacs-lisp/smie.el:
* lisp/ffap.el:
* lisp/progmodes/js.el:
* lisp/progmodes/meta-mode.el:
* lisp/progmodes/octave.el:
* lisp/progmodes/opascal.el:
* lisp/progmodes/pascal.el:
* lisp/progmodes/perl-mode.el:
* lisp/progmodes/prolog.el:
* lisp/progmodes/ruby-mode.el:
* lisp/progmodes/sh-script.el:
* lisp/simple.el:
* lisp/textmodes/tex-mode.el:
* lisp/thingatpt.el:
* lisp/vc/smerge-mode.el: Use new syntax-is-{comment|string}-p
  functions rather than checking (nth 3|4 (syntax-ppss))
---
 lisp/emacs-lisp/smie.el     |  8 ++++----
 lisp/ffap.el                |  2 +-
 lisp/progmodes/js.el        |  4 ++--
 lisp/progmodes/meta-mode.el |  4 ++--
 lisp/progmodes/octave.el    | 10 ++++------
 lisp/progmodes/opascal.el   |  2 +-
 lisp/progmodes/pascal.el    |  2 +-
 lisp/progmodes/perl-mode.el |  4 ++--
 lisp/progmodes/prolog.el    |  4 ++--
 lisp/progmodes/ruby-mode.el |  2 +-
 lisp/progmodes/sh-script.el | 10 +++++-----
 lisp/simple.el              |  2 +-
 lisp/textmodes/tex-mode.el  |  4 ++--
 lisp/thingatpt.el           | 12 +++---------
 lisp/vc/smerge-mode.el      |  2 +-
 15 files changed, 32 insertions(+), 40 deletions(-)

diff --git a/lisp/emacs-lisp/smie.el b/lisp/emacs-lisp/smie.el
index c01a40172b..a82a6e2c99 100644
--- a/lisp/emacs-lisp/smie.el
+++ b/lisp/emacs-lisp/smie.el
@@ -1644,7 +1644,7 @@ smie-indent-comment-continue
   (let ((continue (and comment-continue
                        (comment-string-strip comment-continue t t))))
     (and (< 0 (length continue))
-         (looking-at (regexp-quote continue)) (nth 4 (syntax-ppss))
+         (looking-at (regexp-quote continue)) (syntax-is-comment-p)
          (let ((ppss (syntax-ppss)))
            (save-excursion
              (forward-line -1)
@@ -1660,7 +1660,7 @@ smie-indent-comment-close
        (not (looking-at " \t*$"))       ;Not just a \n comment-closer.
        (looking-at comment-end-skip)
        (let ((end (match-string 0)))
-         (and (nth 4 (syntax-ppss))
+         (and (syntax-is-comment-p)
               (save-excursion
                 (goto-char (nth 8 (syntax-ppss)))
                 (and (looking-at comment-start-skip)
@@ -1674,11 +1674,11 @@ smie-indent-comment-close
                          (current-column)))))))))
 
 (defun smie-indent-comment-inside ()
-  (and (nth 4 (syntax-ppss))
+  (and (syntax-is-comment-p)
        'noindent))
 
 (defun smie-indent-inside-string ()
-  (and (nth 3 (syntax-ppss))
+  (and (syntax-is-string-p)
        'noindent))
 
 (defun smie-indent-after-keyword ()
diff --git a/lisp/ffap.el b/lisp/ffap.el
index b51929d260..5272735147 100644
--- a/lisp/ffap.el
+++ b/lisp/ffap.el
@@ -1161,7 +1161,7 @@ ffap-string-at-point
            (null region-selected)
            ;; Check if END character is part of a comment.
            (save-excursion
-             (nth 4 (syntax-ppss end))))
+             (syntax-is-comment-p end)))
       ;; Move BEG to beginning of comment (after the comment start
       ;; characters), or END, whichever comes first.
       (save-excursion
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index f30e591b15..49020fec05 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -1837,7 +1837,7 @@ js--continued-expression-p
     (if (js--looking-at-operator-p)
         (if (eq (char-after) ?/)
             (prog1
-                (not (nth 3 (syntax-ppss (1+ (point)))))
+                (not (syntax-is-string-p (1+ (point))))
               (forward-char -1))
           (or
            (not (memq (char-after) '(?- ?+)))
@@ -1982,7 +1982,7 @@ js--multi-line-declaration-indentation
           (when (looking-at js--indent-operator-re)
             (goto-char (match-end 0)))
           ;; The "operator" is probably a regexp literal opener.
-          (when (nth 3 (syntax-ppss))
+          (when (syntax-is-string-p)
             (goto-char pt)))
         (while (and (not at-opening-bracket)
                     (not (bobp))
diff --git a/lisp/progmodes/meta-mode.el b/lisp/progmodes/meta-mode.el
index e207d22ff4..2475867adc 100644
--- a/lisp/progmodes/meta-mode.el
+++ b/lisp/progmodes/meta-mode.el
@@ -562,7 +562,7 @@ meta-indent-calculate
 
 (defun meta-indent-in-string-p ()
   "Tell if the point is in a string."
-  (or (nth 3 (syntax-ppss))
+  (or (syntax-is-string-p)
       (eq (get-text-property (point) 'face) font-lock-string-face)))
 
 (defun meta-indent-looking-at-code (regexp)
@@ -636,7 +636,7 @@ meta-indent-current-nesting
 		      nil t)
 		;; If we aren't in a string or in a comment, we've found something.
 		(unless (or (meta-indent-in-string-p)
-			    (nth 4 (syntax-ppss)))
+			    (syntax-is-comment-p))
 		  (cond ((= (char-after) ?\()
 			 (setq to-add (+ to-add meta-indent-level)))
 			((= (char-after) ?\))
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
index 984bb73c73..ec4eaa5fe5 100644
--- a/lisp/progmodes/octave.el
+++ b/lisp/progmodes/octave.el
@@ -995,13 +995,11 @@ inferior-octave-track-window-width-change
 \f
 ;;; Miscellaneous useful functions
 
-(defun octave-in-comment-p ()
-  "Return non-nil if point is inside an Octave comment."
-  (nth 4 (syntax-ppss)))
+(defalias 'octave-in-comment-p 'syntax-is-comment-p
+  "Return non-nil if point is inside an Octave comment.")
 
-(defun octave-in-string-p ()
-  "Return non-nil if point is inside an Octave string."
-  (nth 3 (syntax-ppss)))
+(defalias 'octave-in-string-p 'syntax-is-string-p
+  "Return non-nil if point is inside an Octave string.")
 
 (defun octave-in-string-or-comment-p ()
   "Return non-nil if point is inside an Octave string or comment."
diff --git a/lisp/progmodes/opascal.el b/lisp/progmodes/opascal.el
index 4606621951..7f5f5f4dea 100644
--- a/lisp/progmodes/opascal.el
+++ b/lisp/progmodes/opascal.el
@@ -1705,7 +1705,7 @@ opascal--syntax-propertize
    ("(\\(\\/\\)" (1 (prog1 ". 1c" (forward-char -1) nil)))
    ;; Pascal uses '' and "" rather than \' and \" to escape quotes.
    ("''\\|\"\"" (0 (if (save-excursion
-                         (nth 3 (syntax-ppss (match-beginning 0))))
+                         (syntax-is-string-p (match-beginning 0)))
                        (string-to-syntax ".")
                      ;; In case of 3 or more quotes in a row, only advance
                      ;; one quote at a time.
diff --git a/lisp/progmodes/pascal.el b/lisp/progmodes/pascal.el
index 6d13d328c5..f196bcdeb4 100644
--- a/lisp/progmodes/pascal.el
+++ b/lisp/progmodes/pascal.el
@@ -190,7 +190,7 @@ pascal--syntax-propertize
    ("(\\(\\/\\)" (1 (prog1 ". 1c" (forward-char -1) nil)))
    ;; Pascal uses '' and "" rather than \' and \" to escape quotes.
    ("''\\|\"\"" (0 (if (save-excursion
-                         (nth 3 (syntax-ppss (match-beginning 0))))
+                         (syntax-is-string-p (match-beginning 0)))
                        (string-to-syntax ".")
                      ;; In case of 3 or more quotes in a row, only advance
                      ;; one quote at a time.
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index b96aad7a6e..a217d4f85a 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -231,8 +231,8 @@ perl-syntax-propertize-function
       ;; check that it occurs inside a '..' string.
       ("\\(\\$\\)[{']" (1 (unless (and (eq ?\' (char-after (match-end 1)))
                                        (save-excursion
-                                         (not (nth 3 (syntax-ppss
-                                                      (match-beginning 0))))))
+                                         (not (syntax-is-string-p
+                                               (match-beginning 0)))))
                             (string-to-syntax ". p"))))
       ;; Handle funny names like $DB'stop.
       ("\\$ ?{?^?[_[:alpha:]][_[:alnum:]]*\\('\\)[_[:alpha:]]" (1 "_"))
diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el
index a895a77796..23aed9bafe 100644
--- a/lisp/progmodes/prolog.el
+++ b/lisp/progmodes/prolog.el
@@ -2291,7 +2291,7 @@ prolog-guess-fill-prefix
   ;; fill 'txt entities?
   (when (save-excursion
           (end-of-line)
-          (nth 4 (syntax-ppss)))
+          (syntax-is-comment-p))
     (let* ((bounds (prolog-comment-limits))
            (cbeg (car bounds))
            (type (nth 2 bounds))
@@ -2755,7 +2755,7 @@ prolog-get-predspec
     (let ((state (prolog-clause-info))
           (object (prolog-in-object)))
       (if (or (equal (nth 0 state) "")
-              (nth 4 (syntax-ppss)))
+              (syntax-is-comment-p))
           nil
         (if (and (eq prolog-system 'sicstus)
                  object)
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index fad7bc1fb8..abc66d3f85 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -1849,7 +1849,7 @@ ruby-syntax-propertize
       ;; ?' ?" ?` are character literals (one-char strings in 1.9+).
       ("\\([?$]\\)[#\"'`:?]"
        (1 (if (save-excursion
-                (nth 3 (syntax-ppss (match-beginning 0))))
+                (syntax-is-string-p (match-beginning 0)))
               ;; Within a string, skip.
               (ignore
                (goto-char (match-end 1)))
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index aaa86b5816..26c276504c 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1882,7 +1882,7 @@ sh-smie-sh-forward-token
            (save-excursion
              (skip-chars-backward " \t")
              (not (bolp))))
-      (if (and (match-end 1) (not (nth 3 (syntax-ppss))))
+      (if (and (match-end 1) (not (syntax-is-string-p)))
           ;; Right before a here-doc.
           (let ((forward-sexp-function nil))
             (forward-sexp 1)
@@ -1931,7 +1931,7 @@ sh-smie-sh-backward-token
     (cond
      ((and (bolp) (not (bobp))
            (equal (syntax-after (1- (point))) (string-to-syntax "|"))
-           (not (nth 3 (syntax-ppss))))
+           (not (syntax-is-string-p)))
       ;; Right after a here-document.
       (let ((forward-sexp-function nil))
         (forward-sexp -1)
@@ -2169,7 +2169,7 @@ sh-smie-rc-forward-token
            (save-excursion
              (skip-chars-backward " \t")
              (not (bolp))))
-      (if (and (match-end 1) (not (nth 3 (syntax-ppss))))
+      (if (and (match-end 1) (not (syntax-is-string-p)))
           ;; Right before a here-doc.
           (let ((forward-sexp-function nil))
             (forward-sexp 1)
@@ -2211,7 +2211,7 @@ sh-smie-rc-backward-token
     (cond
      ((and (bolp) (not (bobp))
            (equal (syntax-after (1- (point))) (string-to-syntax "|"))
-           (not (nth 3 (syntax-ppss))))
+           (not (syntax-is-string-p)))
       ;; Right after a here-document.
       (let ((forward-sexp-function nil))
         (forward-sexp -1)
@@ -2827,7 +2827,7 @@ sh-get-indent-info
       ;; Note: setting result to t means we are done and will return nil.
       ;;(This function never returns just t.)
       (cond
-       ((or (nth 3 (syntax-ppss (point)))
+       ((or (syntax-is-string-p)
 	    (eq (get-text-property (point) 'face) 'sh-heredoc))
 	;; String continuation -- don't indent
 	(setq result t)
diff --git a/lisp/simple.el b/lisp/simple.el
index 0ccf2f1d22..fb44c4fac9 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -7264,7 +7264,7 @@ internal-auto-fill
   "The function called by `self-insert-command' to perform auto-filling."
   (when (or (not comment-start)
             (not comment-auto-fill-only-comments)
-            (nth 4 (syntax-ppss)))
+            (syntax-is-comment-p))
     (funcall auto-fill-function)))
 
 (defvar normal-auto-fill-function 'do-auto-fill
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index c223af4769..b6ebc1e3be 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -1328,7 +1328,7 @@ tex-insert-quote
   ;;
   (if (or arg (memq (char-syntax (preceding-char)) '(?/ ?\\))
           (eq (get-text-property (point) 'face) 'tex-verbatim)
-          (nth 4 (syntax-ppss)) ; non-nil if point is in a TeX comment
+          (syntax-is-comment-p)
           ;; Discover if a preceding occurrence of `tex-open-quote'
           ;; should be morphed to a normal double quote.
           ;;
@@ -1487,7 +1487,7 @@ tex-handle-newline
 unless prefix arg INHIBIT-VALIDATION is non-nil to inhibit the checking.
 Otherwise (in a comment), just insert a single continued comment line."
   (interactive "*P")
-  (if (nth 4 (syntax-ppss)) ; non-nil if point is in a TeX comment
+  (if (syntax-is-comment-p)
       (comment-indent-new-line)
     (tex-terminate-paragraph inhibit-validation)))
 
diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el
index 679401eef1..41185a778e 100644
--- a/lisp/thingatpt.el
+++ b/lisp/thingatpt.el
@@ -180,19 +180,13 @@ end-of-thing
 
 ;;  Sexps
 
-(defun in-string-p ()
-  "Return non-nil if point is in a string."
-  (declare (obsolete "use (nth 3 (syntax-ppss)) instead." "25.1"))
-  (let ((orig (point)))
-    (save-excursion
-      (beginning-of-defun)
-      (nth 3 (parse-partial-sexp (point) orig)))))
+(define-obsolete-function-alias 'in-string-p 'syntax-is-string-p "25.1")
 
 (defun thing-at-point--end-of-sexp ()
   "Move point to the end of the current sexp."
   (let ((char-syntax (syntax-after (point))))
     (if (or (eq char-syntax ?\))
-	    (and (eq char-syntax ?\") (nth 3 (syntax-ppss))))
+	    (and (eq char-syntax ?\") (syntax-is-string-p)))
 	(forward-char 1)
       (forward-sexp 1))))
 
@@ -206,7 +200,7 @@ thing-at-point--beginning-of-sexp
   "Move point to the beginning of the current sexp."
   (let ((char-syntax (char-syntax (char-before))))
     (if (or (eq char-syntax ?\()
-	    (and (eq char-syntax ?\") (nth 3 (syntax-ppss))))
+	    (and (eq char-syntax ?\") (syntax-is-string-p)))
 	(forward-char -1)
       (forward-sexp -1))))
 
diff --git a/lisp/vc/smerge-mode.el b/lisp/vc/smerge-mode.el
index ff41473435..056bb4f46d 100644
--- a/lisp/vc/smerge-mode.el
+++ b/lisp/vc/smerge-mode.el
@@ -621,7 +621,7 @@ smerge-resolve
            ;; Idem, when the conflict is contained within a single comment.
            ((save-excursion
               (and m2e
-                   (nth 4 (syntax-ppss m0b))
+                   (syntax-is-comment-p m0b)
                    ;; If there's a conflict earlier in the file,
                    ;; syntax-ppss is not reliable.
                    (not (re-search-backward smerge-begin-re nil t))
-- 
2.18.0

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Noam Postavsky]

Alex Branham <alex.branham@gmail.com> writes:

> I got tired of checking/remembering whether (nth 3 (syntax-ppss)) was a
> string or a comment, so I've created two simple functions that wrap that
> in a more descriptive name. I've noticed that there are a handful of
> these that other modes have written, so evidently others wanted them as
> well at some point.

What about syntax-ppss-context in syntax.el?

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

On Wed 22 Aug 2018 at 22:12, Noam Postavsky <npostavs@gmail.com> wrote:

> Alex Branham <alex.branham@gmail.com> writes:
>
>> I got tired of checking/remembering whether (nth 3 (syntax-ppss)) was a
>> string or a comment, so I've created two simple functions that wrap that
>> in a more descriptive name. I've noticed that there are a handful of
>> these that other modes have written, so evidently others wanted them as
>> well at some point.
>
> What about syntax-ppss-context in syntax.el?

Thanks, I didn't know about syntax-ppss-context. It doesn't seem to be
documented anywhere.

I think I still slightly prefer having these two functions since when
searching for something like "syntax string" syntax-is-string-p will pop
up but syntax-ppss-context won't.

Thanks again,
Alex

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Eli Zaretskii]

> From: Alex Branham <alex.branham@gmail.com>
> Date: Thu, 23 Aug 2018 08:01:36 -0500
> Cc: 32504@debbugs.gnu.org
> 
> > What about syntax-ppss-context in syntax.el?
> 
> Thanks, I didn't know about syntax-ppss-context. It doesn't seem to be
> documented anywhere.

If it's useful, we could document it.

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Phil Sainty]

Note also the "Todo" item in syntax.el:

;; - new functions `syntax-state', ... to replace uses of 
parse-partial-state
;;   with something higher-level (similar to syntax-ppss-context).

Presumably that comment should be removed in any patch for this bug.

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

On Thu 23 Aug 2018 at 08:58, Eli Zaretskii <eliz@gnu.org> wrote:

>> From: Alex Branham <alex.branham@gmail.com>
>> Date: Thu, 23 Aug 2018 08:01:36 -0500
>> Cc: 32504@debbugs.gnu.org
>>
>> > What about syntax-ppss-context in syntax.el?
>>
>> Thanks, I didn't know about syntax-ppss-context. It doesn't seem to be
>> documented anywhere.
>
> If it's useful, we could document it.

I'm ambivalent about its usefulness - I don't see it used anywhere in
Emacs's code and only once in the packages I have installed.

Alex

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Eli Zaretskii]

> From: Alex Branham <alex.branham@gmail.com>
> Cc: npostavs@gmail.com, 32504@debbugs.gnu.org
> Date: Fri, 24 Aug 2018 11:11:47 -0500
> 
> >> > What about syntax-ppss-context in syntax.el?
> >>
> >> Thanks, I didn't know about syntax-ppss-context. It doesn't seem to be
> >> documented anywhere.
> >
> > If it's useful, we could document it.
> 
> I'm ambivalent about its usefulness - I don't see it used anywhere in
> Emacs's code and only once in the packages I have installed.

That could be because it isn't documented.  After all, that was your
reason for not knowing about it, right?

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

On Fri 24 Aug 2018 at 14:28, Eli Zaretskii <eliz@gnu.org> wrote:

> That could be because it isn't documented.  After all, that was your
> reason for not knowing about it, right?

Yes, absolutely. I meant I'm ambivalent about its usefulness versus
syntax-is-comment/string-p, which seem more descriptive to me.

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Noam Postavsky]

Alex Branham <alex.branham@gmail.com> writes:

>>> Thanks, I didn't know about syntax-ppss-context. It doesn't seem to be
>>> documented anywhere.
>>
>> If it's useful, we could document it.
>
> I'm ambivalent about its usefulness - I don't see it used anywhere in
> Emacs's code and only once in the packages I have installed.

For a bit of prior art, there are some similar functions in python.el:
python-syntax-context, python-syntax-context-type,
python-syntax-comment-or-string-p, python-syntax-closing-paren-p.

Also, syntax.el has a couple of commented out "XEmacs compatibility
functions": buffer-syntactic-context, buffer-syntactic-context-depth.

I think it would make sense to provide symbolic names for all the
elements returned by syntax-ppss, maybe like this:

    (cl-defstruct (syntax-state (:constructor nil)
                                (:type list))
      depth list-start sexp-end
      string-start comment quoted
      min-depth comment-style comment-or-string-start
      open-parens syntax-sequence)

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Andreas Röhler]

On 24.08.2018 21:49, Alex Branham wrote:
> 
> On Fri 24 Aug 2018 at 14:28, Eli Zaretskii <eliz@gnu.org> wrote:
> 
>> That could be because it isn't documented.  After all, that was your
>> reason for not knowing about it, right?
> 
> Yes, absolutely. I meant I'm ambivalent about its usefulness versus
> syntax-is-comment/string-p, which seem more descriptive to me.
> 
> 
> 

+1

Using here my home-made ar-in-comment-p, ar-in-string-p

But there is another thing, syntax-ppss-context isn't that convenient: 
it requires still a check for eq instead of simply delivering a boolean.

Andreas

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

> I think it would make sense to provide symbolic names for all the
> elements returned by syntax-ppss, maybe like this:

That makes sense to me.

>     (cl-defstruct (syntax-state (:constructor nil)
>                                 (:type list))
>       depth list-start sexp-end
>       string-start comment quoted
>       min-depth comment-style comment-or-string-start
>       open-parens syntax-sequence)

I'm not a big fan of the docstrings generated by this, is there a way to
change them to be more helpful? For example, syntax-state-comment looks
like this:

syntax-state-comment is a Lisp function.

(syntax-state-comment CL-X)

This function has a compiler macro ‘syntax-state-comment--cmacro’.

Access slot "comment" of ‘(syntax-state (:constructor nil) (:type list))’ struct CL-X.


But it would be a lot better (in my eyes, anyway) if it looked something
like this, had the -p suffix, and made CL-X default to point:

syntax-state-comment-p is a Lisp function.

(syntax-state-comment-p &optional CL-X)

This function has a compiler macro ‘syntax-state-comment-p--cmacro’.

Return non-nil if the syntax of CL-X is a comment. CL-X defaults to point.

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Noam Postavsky]

Alex Branham <alex.branham@gmail.com> writes:

>>     (cl-defstruct (syntax-state (:constructor nil)
>>                                 (:type list))
>>       depth list-start sexp-end
>>       string-start comment quoted
         ^^^^^^^^^^^^
That should be string-terminator

>>       min-depth comment-style comment-or-string-start
>>       open-parens syntax-sequence)
>
> I'm not a big fan of the docstrings generated by this, is there a way to
> change them to be more helpful?

Hmm, doesn't look like it.  Well, that's just a convenient way of
defining them all quickly for discussion, it wouldn't be that much
harder to write out defuns I guess.

> But it would be a lot better (in my eyes, anyway) if it looked something
> like this, had the -p suffix, and made CL-X default to point:

> Return non-nil if the syntax of CL-X is a comment.

I don't think it should be a -p predicate, because there is meaningful
distinction between non-nil values:

     4. nil if outside a comment, t if inside a non-nestable comment,
        else an integer (the current comment nesting).

> CL-X defaults to point.

And, my intention is to operate on the return value of syntax-ppss, not
give a point to call it with.  So it could be used as:

    (syntax-state-comment (syntax-ppss))

or

    (let ((ppss (syntax-ppss)))
      (and (syntax-state-comment ppss)
           (syntax-state-comment-or-string-start ppss)))

or

    (syntax-state-comment (parse-partial-sexp ...))

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Alex Branham]

On Thu 30 Aug 2018 at 20:21, Noam Postavsky <npostavs@gmail.com> wrote:

>> I'm not a big fan of the docstrings generated by this, is there a way to
>> change them to be more helpful?
>
> Hmm, doesn't look like it.  Well, that's just a convenient way of
> defining them all quickly for discussion, it wouldn't be that much
> harder to write out defuns I guess.

Fair enough.

> I don't think it should be a -p predicate, because there is meaningful
> distinction between non-nil values:
>
>      4. nil if outside a comment, t if inside a non-nestable comment,
>         else an integer (the current comment nesting).

That makes sense, but the -p predicate seems more discoverable to me. We
can always note in the docstring that the actual return value is usable.
I don't have a super strong opinion though.

>> CL-X defaults to point.
>
> And, my intention is to operate on the return value of syntax-ppss, not
> give a point to call it with.  So it could be used as:
>
>     (syntax-state-comment (syntax-ppss))
>
> or
>
>     (let ((ppss (syntax-ppss)))
>       (and (syntax-state-comment ppss)
>            (syntax-state-comment-or-string-start ppss)))
>
> or
>
>     (syntax-state-comment (parse-partial-sexp ...))

Right, but whenever I want to call on these functions, 90% of the time
the question I'm trying to answer is "Is point in a comment/string?" And
the 3rd party ***-is-comment/string-p functions I've looked at usually
(always?) look at positions.

Thanks,
Alex

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Lars Ingebrigtsen]

Noam Postavsky <npostavs@gmail.com> writes:

> Alex Branham <alex.branham@gmail.com> writes:
>
>> I got tired of checking/remembering whether (nth 3 (syntax-ppss)) was a
>> string or a comment, so I've created two simple functions that wrap that
>> in a more descriptive name. I've noticed that there are a handful of
>> these that other modes have written, so evidently others wanted them as
>> well at some point.
>
> What about syntax-ppss-context in syntax.el?

I went ahead and documented it; if I read this thread right, it's
sufficient for the use case presented.

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Noam Postavsky]

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

Alex Branham <alex.branham@gmail.com> writes:

> On Thu 30 Aug 2018 at 20:21, Noam Postavsky <npostavs@gmail.com> wrote:
>
>>> I'm not a big fan of the docstrings generated by this, is there a way to
>>> change them to be more helpful?
>>
>> Hmm, doesn't look like it.  Well, that's just a convenient way of
>> defining them all quickly for discussion, it wouldn't be that much
>> harder to write out defuns I guess.
>
> Fair enough.

The recent talk about accessors for decoded time reminded me of this.
Here's an initial patch.


[-- Attachment #2: patch --]
[-- Type: text/plain, Size: 4457 bytes --]

From 0d09658a33aed36b0b647dc8dbfd08d8aa2dc535 Mon Sep 17 00:00:00 2001
From: Noam Postavsky <npostavs@gmail.com>
Date: Mon, 8 Jul 2019 18:45:53 -0400
Subject: [PATCH] Add named accessors for syntax-ppss state (Bug#32504)

* lisp/emacs-lisp/syntax.el (syntax-ppss-depth, syntax-ppss-list-start)
(syntax-ppss-last-sexp-start, syntax-ppss-string-terminator)
(syntax-ppss-comment, syntax-ppss-quoted-p, syntax-ppss-min-depth)
(syntax-ppss-comment-style, syntax-ppss-context-start)
(syntax-ppss-open-parens, syntax-ppss-syntax-sequence): New functions.
(syntax-ppss-toplevel-pos, syntax-ppss-context): Use them.
---
 lisp/emacs-lisp/syntax.el | 62 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 58 insertions(+), 4 deletions(-)

diff --git a/lisp/emacs-lisp/syntax.el b/lisp/emacs-lisp/syntax.el
index 6464e2a52d..b7a5e585b7 100644
--- a/lisp/emacs-lisp/syntax.el
+++ b/lisp/emacs-lisp/syntax.el
@@ -358,7 +358,61 @@ internal--syntax-propertize
 ;;; Incrementally compute and memoize parser state.
 
 (defsubst syntax-ppss-depth (ppss)
+  "Depth in parens according to PPSS.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
   (nth 0 ppss))
+(defsubst syntax-ppss-list-start (ppss)
+  "Start of innermost containing list according to PPSS; nil if none.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 1 ppss))
+(defsubst syntax-ppss-last-sexp-start (ppss)
+  "Start of last complete sexp terminated according to PPSS.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 2 ppss))
+(defsubst syntax-ppss-string-terminator (ppss)
+  "Terminating character of current string according to PPSS.
+Return t if the string should be terminated by generic string
+delimiter, or nil if not in a string.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 3 ppss))
+(defsubst syntax-ppss-comment (ppss)
+  "Non-nil if inside a comment according to PPSS.
+Return t if inside a non-nestable comment, else an integer (the comment
+nesting depth).
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 4 ppss))
+(defsubst syntax-ppss-quoted-p (ppss)
+  "Non-nil if PPSS points to a position following a quote.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 5 ppss))
+(defsubst syntax-ppss-min-depth (ppss)
+  "Minimum parenthesis depth of the scan according to PPSS.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 6 ppss))
+(defsubst syntax-ppss-comment-style (ppss)
+  ;; FIXME: What is comment style exactly?
+  "Comment style according to PPSS.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 7 ppss))
+(defsubst syntax-ppss-context-start (ppss)
+  "Start of comment or string according to PPSS.
+Return nil if not in one.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 8 ppss))
+(defsubst syntax-ppss-open-parens (ppss)
+  "List of open parens according to PPSS.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 9 ppss))
+(defsubst syntax-ppss-syntax-sequence (ppss)
+  "Syntax of the 1st of a two character sequence according to PPSS.
+When the last position scanned holds the first character of a
+\(potential) two character construct, the syntax of that
+position, otherwise nil.  That construct can be a two character
+comment delimiter or an Escaped or Char-quoted character.
+PPSS is the return value `parse-partial-sexp' or `syntax-ppss'."
+  (nth 10 ppss))
+
+
 
 (defun syntax-ppss-toplevel-pos (ppss)
   "Get the latest syntactically outermost position found in a syntactic scan.
@@ -367,8 +421,8 @@ syntax-ppss-toplevel-pos
 outside of any parentheses, comments, or strings encountered in the scan.
 If no such position is recorded in PPSS (because the end of the scan was
 itself at the outermost level), return nil."
-  (or (car (nth 9 ppss))
-      (nth 8 ppss)))
+  (or (car (syntax-ppss-open-parens ppss))
+      (syntax-ppss-context-start ppss)))
 
 (defsubst syntax-ppss-context (ppss)
   "Say whether PPSS is a string, a comment, or something else.
@@ -376,8 +430,8 @@ syntax-ppss-context
 comment, the symbol `comment' is returned.  If it's something
 else, nil is returned."
   (cond
-   ((nth 3 ppss) 'string)
-   ((nth 4 ppss) 'comment)
+   ((syntax-ppss-string-terminator ppss) 'string)
+   ((syntax-ppss-comment ppss) 'comment)
    (t nil)))
 
 (defvar syntax-ppss-max-span 20000
-- 
2.11.0


[-- Attachment #3: Type: text/plain, Size: 610 bytes --]


>>> CL-X defaults to point.
>>
>> And, my intention is to operate on the return value of syntax-ppss, not
>> give a point to call it with.
>
> Right, but whenever I want to call on these functions, 90% of the time
> the question I'm trying to answer is "Is point in a comment/string?" And
> the 3rd party ***-is-comment/string-p functions I've looked at usually
> (always?) look at positions.

Well, for me I just want to stop having to look up the docstring of
parse-partial-sexp every damn time I see (nth X PPSS).  But I wouldn't
be against having syntax-is-comment/string-p which take a position as
well.

bug#32504: [PATCH] syntax-is-{comment|string}-p

[Leo Liu]

On 2019-07-08 20:05 -0400, Noam Postavsky wrote:
> Well, for me I just want to stop having to look up the docstring of
> parse-partial-sexp every damn time I see (nth X PPSS).  But I wouldn't
> be against having syntax-is-comment/string-p which take a position as
> well.

syntax-ppss-context looks better. It is there for a long time and I have
personally used it many times (13 times in one of my projects).
Introduce a new set seems overkill at this point.

BTW, please don't name functions combining -is- and -p. They sound odd.