show-paren-mode only highlights when cursor is one character after closing parenthesis

Question

Problem

I have show-paren-mode enabled, but the highlighting behavior unintuitive. In particular, the matching parentheses are only highlighted in two situations as shown below (the second of which is unintuitive):

1. Cursor on the opening parenthesis (which is expected behavior):

   ( some characters here ) some more characters here
   ^
   cursor must be at the caret for highlighting to show
   

2. Cursor on the character after the closing parenthesis (which is unintuitive):

   ( some characters here ) some more characters here
                           ^
                           cursor must be at the caret for highlighting to show
   

Question

Is there a way for the matching parentheses to be highlighted when the cursor is on the closing parenthesis?

Like this:

( some characters here ) some more characters here
                       ^

Answer 1

The following mutilating shortening of show-paren--locate-near-paren does what you want.

Copy these lines into your init file and restart Emacs.

(defun show-paren--locate-near-paren-ad ()
  "Locate an unescaped paren \"near\" point to show.
If one is found, return the cons (DIR . OUTSIDE), where DIR is 1
for an open paren, -1 for a close paren, and OUTSIDE is the buffer
position of the outside of the paren.  Otherwise return nil."
  (let* ((before (show-paren--categorize-paren (point))))
    (when (or
       (eq (car before) 1)
       (eq (car before) -1))
      before)))

(advice-add 'show-paren--locate-near-paren :override #'show-paren--locate-near-paren-ad)

Answer 2

The following advice does what you want. When the block cursor is "on" the opening parenthesis, the closing parenthesis is highlighted. When the block cursor is "on" the closing parenthesis, the opening parenthesis is highlighted.

(advice-add show-paren-data-function
            :around
            (lambda (orig-fun)
              (cond ((looking-at "\\s(")
                     (funcall orig-fun))
                    ((looking-at "\\s)")
                     (save-excursion (forward-char 1) (funcall orig-fun))))))

The first cond clause handles an opening delimiter character (e.g. when the cursor is "on" an opening parenthesis). Since the default Emacs behavior already does what you want, we do not need to change the behavior, so we just reuse the original function.

The second cond clause handles a closing delimiter character (e.g. when the cursor is "on" a closing parenthesis). The default Emacs behavior is not doing what you want. To solve the problem, we "trick" the original function into believing that the cursor is right after the closing parenthesis whenever the cursor is "on" the closing parenthesis.

Otherwise, we return nil.

---

You may also want to consider this variant:

(advice-add show-paren-data-function
            :around
            (lambda (orig-fun)
              (cond ((looking-at "\\s)")
                     (save-excursion (forward-char 1) (funcall orig-fun)))
                    (t (funcall orig-fun)))))

When the block cursor is "on" a closing parenthesis, it will highlight the opening parenthesis. When the block cursor is not "on" a closing parenthesis, but the previous character is a closing parenthesis, it will highlight the opening parenthesis.

I have tried these code snippets in GNU Emacs 26.3.

Answer 3

I believe setting show-paren-when-point-inside-paren to t does what you want.

From the docs:

Documentation:
If non-nil, show parens when point is just inside one.
This will only be done when point isn’t also just outside a paren.

Can be set with:

(setq show-paren-when-point-inside-paren t)