(require 'treesit)

(declare-function neocaml-mode--font-lock-settings "neocaml")

(defgroup neocaml-ocamllex nil

"Major mode for editing OCamllex files with tree-sitter."

:prefix "neocaml-ocamllex-"

:group 'languages

:link '(url-link :tag "GitHub" "https://github.com/bbatsov/neocaml"))

(defcustom neocaml-ocamllex-indent-offset 2

"Number of spaces for each indentation step in `neocaml-ocamllex-mode'."

:type 'natnum

:safe 'natnump

:group 'neocaml-ocamllex

:package-version '(neocaml . "0.7.0"))

(defconst neocaml-ocamllex-grammar-recipes

'((ocamllex "https://github.com/314eter/tree-sitter-ocamllex"

"v0.24.0"

"src"))

"Tree-sitter grammar recipe for OCamllex files.

Suitable for use as the value of `treesit-language-source-alist'.")

(defun neocaml-ocamllex-install-grammar (&optional force)

"Install the OCamllex tree-sitter grammar if not already available.

(interactive "P")

(when (or force (not (treesit-language-available-p 'ocamllex nil)))

(message "Installing OCamllex tree-sitter grammar...")

(let ((treesit-language-source-alist neocaml-ocamllex-grammar-recipes))

(treesit-install-language-grammar 'ocamllex))))

(defvar neocaml-ocamllex--font-lock-settings

(treesit-font-lock-rules

:language 'ocamllex

:feature 'comment

'((comment) @font-lock-comment-face)

:language 'ocamllex

:feature 'keyword

'(["and" "as" "let" "parse" "refill" "rule" "shortest"]

@font-lock-keyword-face)

:language 'ocamllex

:feature 'definition

'((lexer_entry name: (lexer_entry_name) @font-lock-function-name-face)

(named_regexp name: (regexp_name) @font-lock-variable-name-face))

:language 'ocamllex

:feature 'string

'((string) @font-lock-string-face

(character) @font-lock-string-face)

:language 'ocamllex

:feature 'escape-sequence

:override t

'((escape_sequence) @font-lock-escape-face)

:language 'ocamllex

:feature 'constant

'((any) @font-lock-constant-face

(eof) @font-lock-constant-face)

:language 'ocamllex

:feature 'variable

'((regexp_name) @font-lock-variable-use-face)

:language 'ocamllex

:feature 'operator

'((regexp_repetition ["*" "+" "?"] @font-lock-operator-face)

(regexp_difference "#" @font-lock-operator-face))

:language 'ocamllex

:feature 'bracket

'(["(" ")" "[" "]" "{" "}"] @font-lock-bracket-face)

:language 'ocamllex

:feature 'delimiter

'(["=" "|" "-"] @font-lock-delimiter-face))

"Font-lock settings for `neocaml-ocamllex-mode'.")

(defun neocaml-ocamllex--injection-available-p ()

"Non-nil if OCaml language injection is available.

(and (>= emacs-major-version 30)

(treesit-language-available-p 'ocaml)))

(defun neocaml-ocamllex--font-lock-settings ()

"Return font-lock settings for `neocaml-ocamllex-mode'.

(append

neocaml-ocamllex--font-lock-settings

(when (neocaml-ocamllex--injection-available-p)

(require 'neocaml)

(neocaml-mode--font-lock-settings 'ocaml))))

(defun neocaml-ocamllex--range-settings ()

"Return range settings for embedded OCaml code injection.

(when (neocaml-ocamllex--injection-available-p)

(treesit-range-rules

:embed 'ocaml

:host 'ocamllex

:local t

'((ocaml) @capture))))

(defvar neocaml-ocamllex--indent-rules

`((ocamllex

((parent-is "lexer_definition") column-0 0)

((node-is "}") parent-bol 0)

;; Don't reindent inside OCaml code blocks

((parent-is "ocaml") no-indent 0)

;; Lexer cases (| regexp { action })

((node-is "lexer_case") parent-bol neocaml-ocamllex-indent-offset)

;; Inside a lexer entry

((parent-is "lexer_entry") parent-bol neocaml-ocamllex-indent-offset)

;; Inside character sets

((parent-is "character_set") parent-bol 0)

;; Catch-all

(no-node parent-bol neocaml-ocamllex-indent-offset)))

"Indentation rules for `neocaml-ocamllex-mode'.")

(defvar neocaml-ocamllex--imenu-settings

'(("Rule" "\\`lexer_entry\\'" nil nil)

("Regexp" "\\`named_regexp\\'" nil nil))

"Imenu settings for `neocaml-ocamllex-mode'.

See `treesit-simple-imenu-settings' for the format.")

(defun neocaml-ocamllex--defun-name (node)

"Return a name for NODE suitable for imenu and which-func."

(pcase (treesit-node-type node)

("lexer_entry"

(let ((name (treesit-node-child-by-field-name node "name")))

(when name (treesit-node-text name t))))

("named_regexp"

(let ((name (treesit-node-child-by-field-name node "name")))

(when name (treesit-node-text name t))))))

(define-derived-mode neocaml-ocamllex-mode prog-mode "OCamllex"

"Major mode for editing OCamllex lexer definition files.

(when (< (treesit-library-abi-version) 14)

(error "The OCamllex grammar requires tree-sitter ABI version 14+, but \

tree-sitter >= 0.24" (treesit-library-abi-version)))

(unless (treesit-ready-p 'ocamllex)

(when (y-or-n-p "OCamllex tree-sitter grammar is not installed. Install it now?")

(neocaml-ocamllex-install-grammar))

(unless (treesit-ready-p 'ocamllex)

(error "Cannot activate neocaml-ocamllex-mode without the OCamllex grammar")))

(treesit-parser-create 'ocamllex)

;; Comments (OCaml-style)

(setq-local comment-start "(* ")

(setq-local comment-end " *)")

(setq-local comment-start-skip "(\\*+ *")

;; Language injection for embedded OCaml code

(let ((range-settings (neocaml-ocamllex--range-settings)))

(when range-settings

(setq-local treesit-range-settings range-settings)))

;; Font-lock

(setq-local treesit-font-lock-settings (neocaml-ocamllex--font-lock-settings))

(setq-local treesit-font-lock-feature-list

'((comment definition)

(keyword string type)

(constant escape-sequence attribute builtin number)

(variable operator bracket delimiter property label function)))

;; Indentation

(setq-local treesit-simple-indent-rules neocaml-ocamllex--indent-rules)

(setq-local indent-tabs-mode nil)

;; Imenu

(setq-local treesit-simple-imenu-settings neocaml-ocamllex--imenu-settings)

;; Navigation

(setq-local treesit-defun-type-regexp

"\\`\\(?:lexer_entry\\|named_regexp\\)\\'")

(setq-local treesit-defun-name-function #'neocaml-ocamllex--defun-name)

(setq-local add-log-current-defun-function #'treesit-add-log-current-defun)

;; Final newline

(setq-local require-final-newline mode-require-final-newline)

;; Make URLs and bug references in comments clickable

(goto-address-prog-mode)

(bug-reference-prog-mode)

(treesit-major-mode-setup))

(add-to-list 'auto-mode-alist '("\\.mll\\'" . neocaml-ocamllex-mode))

(provide 'neocaml-ocamllex)