If I am in a comment (including empty lines), how do I get to the beginning of the comment?

Question

I have the following problem:

I am in a comment or the empty lines after or within the comment. I want to get to the first line of the comment.

So no matter where I am in this commented block, I want to get to the beginning of line ;; blah blah.

M-x butterfly

;; blah blah 

;; spoon

;; blah blah blah


;; swordfish

I think I have solved it, albeit clumsily:

(defun beginning-of-comment ()
      (interactive)
      (while
          (progn
            (beginning-of-line)
            (looking-at (rx-to-string (or
              `(: line-start (zero-or-more whitespace) (one-or-more ,comment-start))
              `(: line-start (zero-or-more whitespace) line-end))))))
      (previous-line))

Problem is, I cannot use the solution above, because it makes my emacs crash (and would presumably make other's emacs' with the same OS/emacs version crash too if I were to PR it).

There must be a more idiomatic, less verbose way to get to the beginning of a comment from within it.

Ninja edit: I thought of one more, but this also crashes emacs (becomes totally unresponsive):

(defun testing ()
  (interactive)
  (while (comment-forward) (progn (previous-line) (previous-line)))

Ps. I want this to work in as many modes as possible, so please use comment-start, do not hardcode the comment variable.

Answer 1

You can use syntax-ppss to find out if the point is in a comment or not. When it is, it also provides information about where the comment started. The following code wraps this into a loop, skipping empty lines etc.

(defun my-comment-start-position ()
  "The position of the start of the current comment, or nil."
  (save-excursion
    (let ((res nil))
      (while (progn
               (skip-chars-backward " \t\n")
               (let ((state (syntax-ppss)))
                 (if (nth 4 state)
                     (let ((start (nth 8 state)))
                       (setq res start)
                       (goto-char start)
                       t)
                   nil))))
      res)))

The code is more robust than looking at regexp:s, since it handles difficult languages where the comment syntax must be defined programatically using a syntax-propertize-function.

Also, it is more robust than checking the face property:

• Some users don't like syntax highlighting and disable font-lock
• font-lock isn't active in batch mode
• font-lock only highlights visible parts of the buffer
• The face property doesn't have to contain a single symbol (see below), code reading it must handle all cases. (This happens, for example, when highlighing additional things inside comments.)
• Badly written font-lock keywords sometimes replace the existing face rather than prepending or appending
• Some comments may be highlighted using another face, e.g. if you have javadoc-style comments font-lock-doc-face is used.

From the elisp manual:

‘face’

The ‘face’ property controls the appearance of the character (*note
Faces::).  The value of the property can be the following:

   • A face name (a symbol or string).

   • An anonymous face: a property list of the form ‘(KEYWORD VALUE
     …)’, where each KEYWORD is a face attribute name and VALUE is
     a value for that attribute.

   • A list of faces.  Each list element should be either a face
     name or an anonymous face.  This specifies a face which is an
     aggregate of the attributes of each of the listed faces.
     Faces occurring earlier in the list have higher priority.

   • A cons cell of the form ‘(foreground-color . COLOR-NAME)’ or
     ‘(background-color . COLOR-NAME)’.  This specifies the
     foreground or background color, similar to ‘(:foreground
     COLOR-NAME)’ or ‘(:background COLOR-NAME)’.  This form is
     supported for backward compatibility only, and should be
     avoided.

Answer 2

Here's an example I could think of, not sure it will handle all corner cases (maybe some modes use different faces for eg.)

(defun my/move-beginning-of-comment ()
  (interactive)
  (while (member (get-char-property (point) 'face)
                 (list font-lock-comment-face
                       font-lock-comment-delimiter-face))
    (backward-char)
    (skip-chars-backward " \t\n")))

Below is a slightly shorter way to write the same function Lindydancer posted:

(defun my-comment-start-position ()
  "The position of the start of the current comment, or nil."
  (save-excursion
    (let (pos)
      (while (let* ((parse (syntax-ppss))
                    (move (and (nth 4 parse) (nth 8 parse))))
               (when move (goto-char (setq pos move))))
        (skip-chars-backward " \t\n"))
    (or pos (point)))))

Answer 3

More robust, but also more verbose:

(defun beginning-of-comment ()
  "When within a comment block - including empty lines - iterates backwards until the beginning."
  (interactive)
  (progn
    (while
        (progn
          (beginning-of-line)
          (or
           ;; Not working to use ?\n in rx-to-string for some reason
           (looking-at (rx (zero-or-more whitespace) ?\n))
           (looking-at (rx-to-string
                        `(: line-start (zero-or-more whitespace) (one-or-more ,comment-start))))))
      (previous-line))
    ;; If we end up in a code line, move one line forward.
    (unless
        (looking-at (rx (zero-or-more whitespace) line-end))
      (next-line)
      (beginning-of-line))))