bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

[Andreas Matthias]

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

Take this example Elisp file:


;;; xxx -- OK: face is outline-1
;;;; xxx -- OK: face is outline-2
(defun test ()) ; WRONG: face is outline-8

;; Local Variables:
;; outline-minor-mode-highlight: override
;; eval: (outline-minor-mode 1)
;; End:


After loading this file into Emacs you will see that the function definition
is displayed incorrectly in face outline-8.

I guess this is due to the definition of outline-regexp in lisp-mode.el:

";;;;* [^
\t\n]\\|(\\|\\(^;;;###\\(\\([-[:alnum:]]+?\\)-\\)?\\(autoload\\)\\)"

Notice the opening parenthesis in the regular expression that causes
the function definition to be recognized as an outline heading.

I removed the opening parenthesis and now the face of the function
definition
is correct. This is fine for me. But note that you loose the ability to move
to top-level expressions, like this function definition, with
(outline-next-visible-heading) and (outline-previous-visible-heading).


Andreas

[-- Attachment #2: Type: text/html, Size: 1164 bytes --]

bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

[Juri Linkov]

> Take this example Elisp file:
>
> ;;; xxx -- OK: face is outline-1
> ;;;; xxx -- OK: face is outline-2
> (defun test ()) ; WRONG: face is outline-8
>
> ;; Local Variables:
> ;; outline-minor-mode-highlight: override
> ;; eval: (outline-minor-mode 1)
> ;; End:
>
> After loading this file into Emacs you will see that the function
> definition
> is displayed incorrectly in face outline-8.
>
> I guess this is due to the definition of outline-regexp in lisp-mode.el:
>
> ";;;;* [^ \t\n]\\|(\\|\\(^;;;###\\(\\([-[:alnum:]]+?\\)-\\)?\\
> (autoload\\)\\)"
>
> Notice the opening parenthesis in the regular expression that causes
> the function definition to be recognized as an outline heading.
>
> I removed the opening parenthesis and now the face of the function
> definition
> is correct. This is fine for me. But note that you loose the ability to
> move
> to top-level expressions, like this function definition, with
> (outline-next-visible-heading) and (outline-previous-visible-heading).

Isn't the face 'outline-8' because 'lisp-outline-level' returns
the level 1000 for the opening parenthesis in 'lisp-outline-level':

  (defun lisp-outline-level ()
    (let ((len (- (match-end 0) (match-beginning 0))))
      (cond ((or (looking-at-p "(")
                 (looking-at-p lisp-mode-autoload-regexp))
             1000)

The level 1000 corresponds to outline-8:

Level    1 - outline-1
Level    2 - outline-2
Level    3 - outline-3
Level    4 - outline-4
Level    5 - outline-5
Level    6 - outline-6
Level    7 - outline-7
Level    8 - outline-8
Level    9 - outline-1
Level   10 - outline-2
Level   11 - outline-3
...
Level  998 - outline-6
Level  999 - outline-7
Level 1000 - outline-8

bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

[Andreas Matthias]

On Sat, Nov 2, 2024 at 6:16 PM Juri Linkov <juri@linkov.net> wrote:
>
> > I guess this is due to the definition of outline-regexp in lisp-mode.el:
> >
> > ";;;;* [^ \t\n]\\|(\\|\\(^;;;###\\(\\([-[:alnum:]]+?\\)-\\)?\\
> > (autoload\\)\\)"

[...]

> Isn't the face 'outline-8' because 'lisp-outline-level' returns
> the level 1000 for the opening parenthesis in 'lisp-outline-level':
>
>   (defun lisp-outline-level ()
>     (let ((len (- (match-end 0) (match-beginning 0))))
>       (cond ((or (looking-at-p "(")
>                  (looking-at-p lisp-mode-autoload-regexp))
>              1000)

AFAIU font-lock is using `outline-regexp` which triggers
`outline-font-lock-face()`
and eventually `lisp-outline-level()`.

My naive approach was to modify `outline-regexp`, i.e. remove the
opening parenthesis
in the regexp. Then `outline-font-lock-face()` cannot be triggered by
this regexp any more
and thus won't override the faces of normal lisp code.

The issue with this approach is: All commands that show, hide, or move to
outline headings use `outline-regexp` as well. Thus these commands won't
find headings starting with an opening parenthesis.

I don't know how important this opening-parenthesis-rule is. Actually I don't
need it. But I guess there were reasons to add it to the regexp.

Andreas

bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

[Juri Linkov]

> I don't know how important this opening-parenthesis-rule is. Actually I don't
> need it. But I guess there were reasons to add it to the regexp.

So there is no bug here and this report could be closed?

If you don't need opening-parenthesis-rule, it's fine
to customize 'outline-regexp' and 'outline-level'.

bug#74156: 29.4; Incorrect face with outline-minor-mode-highlight in lisp-mode

[Andreas Matthias]

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

On Sun, Nov 3, 2024 at 6:58 PM Juri Linkov <juri@linkov.net> wrote:

> > I don't know how important this opening-parenthesis-rule is. Actually I
> don't
> > need it. But I guess there were reasons to add it to the regexp.
>
> So there is no bug here and this report could be closed?
>
> If you don't need opening-parenthesis-rule, it's fine
> to customize 'outline-regexp' and 'outline-level'.
>

Please take a look at the example I have given in my very first post.
There you see that font-lock is handling top-level lisp code incorrectly.
This is definitely a bug.

I don't agree with  you that customizing a variable is the recommended
way to fix a bug. But if there's really no other way to handle it, then it
should be documented at least.

Andreas

[-- Attachment #2: Type: text/html, Size: 1982 bytes --]