mirror of
https://github.com/masscollaborationlabs/emacs.git
synced 2025-07-04 03:13:24 +00:00
1a76b527ac
* lisp/treesit.el (treesit-language-source-alist): Document the format that uses keywords. (treesit--install-language-grammar-1): Remove args 'revision', 'source-dir', 'cc', 'c++', 'commit'. Use 'args' to process the keywords, and use the remaining list as the previous list of arguments. (treesit--install-language-grammar-1): Let-bind 'treesit--install-language-grammar-full-clone' and 'treesit--install-language-grammar-blobless' to t when 'commit' is non-nil (bug#78542). * lisp/progmodes/c-ts-mode.el: * lisp/progmodes/cmake-ts-mode.el: * lisp/progmodes/csharp-mode.el: * lisp/progmodes/dockerfile-ts-mode.el: * lisp/progmodes/elixir-ts-mode.el: * lisp/progmodes/go-ts-mode.el: * lisp/progmodes/heex-ts-mode.el: * lisp/progmodes/java-ts-mode.el: * lisp/progmodes/js.el: * lisp/progmodes/json-ts-mode.el: * lisp/progmodes/php-ts-mode.el: * lisp/progmodes/python.el: * lisp/progmodes/ruby-ts-mode.el: * lisp/progmodes/rust-ts-mode.el: * lisp/progmodes/sh-script.el: * lisp/progmodes/typescript-ts-mode.el: * lisp/textmodes/css-mode.el: * lisp/textmodes/html-ts-mode.el: * lisp/textmodes/markdown-ts-mode.el: * lisp/textmodes/toml-ts-mode.el: * lisp/textmodes/yaml-ts-mode.el: Use the keyword :commit with full hashes instead of tags in 'treesit-language-source-alist'. * lisp/treesit-x.el (define-treesit-generic-mode): Simplify the keyword :copy-queries. (gitattributes-generic-ts-mode, liquid-generic-ts-mode): Add keywords :commit and :copy-queries to :source. * admin/tree-sitter/treesit-admin.el (treesit-admin--unversioned-treesit-language-source-alist): Handle :revision and :commit as well. (treesit-admin--find-latest-compatible-revision): Process the keywords in the recipe.
532 lines
21 KiB
EmacsLisp
532 lines
21 KiB
EmacsLisp
;;; java-ts-mode.el --- tree-sitter support for Java -*- lexical-binding: t; -*-
|
|
|
|
;; Copyright (C) 2022-2025 Free Software Foundation, Inc.
|
|
|
|
;; Author : Theodor Thornhill <theo@thornhill.no>
|
|
;; Maintainer : Theodor Thornhill <theo@thornhill.no>
|
|
;; Created : November 2022
|
|
;; Keywords : java languages tree-sitter
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
;; it under the terms of the GNU General Public License as published by
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
;; (at your option) any later version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;; GNU General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
;;; Tree-sitter language versions
|
|
;;
|
|
;; java-ts-mode has been tested with the following grammars and version:
|
|
;; - tree-sitter-java: v0.23.5
|
|
;;
|
|
;; We try our best to make builtin modes work with latest grammar
|
|
;; versions, so a more recent grammar has a good chance to work too.
|
|
;; Send us a bug report if it doesn't.
|
|
|
|
;;; Commentary:
|
|
;;
|
|
;; If the tree-sitter doxygen grammar is available, then the comment
|
|
;; blocks can be highlighted according to this grammar.
|
|
|
|
;;; Code:
|
|
|
|
(require 'treesit)
|
|
(eval-when-compile (require 'rx))
|
|
(require 'c-ts-common) ; For comment indent and filling.
|
|
(treesit-declare-unavailable-functions)
|
|
|
|
(add-to-list
|
|
'treesit-language-source-alist
|
|
'(java "https://github.com/tree-sitter/tree-sitter-java"
|
|
:commit "94703d5a6bed02b98e438d7cad1136c01a60ba2c")
|
|
t)
|
|
(add-to-list
|
|
'treesit-language-source-alist
|
|
'(doxygen "https://github.com/tree-sitter-grammars/tree-sitter-doxygen"
|
|
:commit "1e28054cb5be80d5febac082706225e42eff14e6")
|
|
t)
|
|
|
|
(defcustom java-ts-mode-indent-offset 4
|
|
"Number of spaces for each indentation step in `java-ts-mode'."
|
|
:version "29.1"
|
|
:type 'integer
|
|
:safe 'integerp
|
|
:group 'java)
|
|
|
|
(defcustom java-ts-mode-method-chaining-indent-offset 8
|
|
"Indent offset for method chaining in `java-ts-mode'."
|
|
:version "31.1"
|
|
:type 'integer
|
|
:safe 'integerp
|
|
:group 'java)
|
|
|
|
(defcustom java-ts-mode-enable-doxygen nil
|
|
"Enable doxygen syntax highlighting.
|
|
If Non-nil, enable doxygen based font lock for comment blocks.
|
|
This needs to be set before enabling `java-ts-mode'; if you change
|
|
the value after enabling `java-ts-mode', toggle the mode off and on
|
|
again."
|
|
:version "31.1"
|
|
:type 'boolean
|
|
:safe 'booleanp
|
|
:group 'java)
|
|
|
|
(defvar java-ts-mode--syntax-table
|
|
(let ((table (make-syntax-table)))
|
|
;; Taken from the cc-langs version
|
|
(modify-syntax-entry ?_ "_" table)
|
|
(modify-syntax-entry ?\\ "\\" table)
|
|
(modify-syntax-entry ?+ "." table)
|
|
(modify-syntax-entry ?- "." table)
|
|
(modify-syntax-entry ?= "." table)
|
|
(modify-syntax-entry ?% "." table)
|
|
(modify-syntax-entry ?< "." table)
|
|
(modify-syntax-entry ?> "." table)
|
|
(modify-syntax-entry ?& "." table)
|
|
(modify-syntax-entry ?| "." table)
|
|
(modify-syntax-entry ?\' "\"" table)
|
|
(modify-syntax-entry ?\240 "." table)
|
|
(modify-syntax-entry ?/ ". 124b" table)
|
|
(modify-syntax-entry ?* ". 23" table)
|
|
(modify-syntax-entry ?\n "> b" table)
|
|
(modify-syntax-entry ?\^m "> b" table)
|
|
(modify-syntax-entry ?@ "'" table)
|
|
table)
|
|
"Syntax table for `java-ts-mode'.")
|
|
|
|
(defun java-ts-mode--standalone-predicate (node)
|
|
"Java's standalone predicate.
|
|
Return t if NODE is on the start of a line."
|
|
(save-excursion
|
|
(goto-char (treesit-node-start node))
|
|
(if (looking-back (rx bol (* whitespace) (? ".")) (pos-bol))
|
|
t
|
|
(back-to-indentation)
|
|
(when (eq (char-after) ?.)
|
|
(point)))))
|
|
|
|
(defun java-ts-mode--first-line-on-multi-line-string (_node parent _bol &rest _)
|
|
"Simple-indent matcher for the first line in a multi-line string block.
|
|
PARENT and BOL are the as in other matchers."
|
|
(and (treesit-node-match-p parent "multiline_string_fragment")
|
|
(save-excursion
|
|
;; Less than 2 newlines between point and string start.
|
|
(not (search-backward "\n" (treesit-node-start parent) t 2)))))
|
|
|
|
(defvar java-ts-mode--indent-rules
|
|
`((java
|
|
((parent-is "program") column-0 0)
|
|
((match "}" "element_value_array_initializer")
|
|
parent-bol 0)
|
|
((node-is
|
|
,(format "\\`%s\\'"
|
|
(regexp-opt '("constructor_body" "class_body" "interface_body"
|
|
"block" "switch_block" "array_initializer"))))
|
|
parent-bol 0)
|
|
((node-is "}") standalone-parent 0)
|
|
((node-is ")") parent-bol 0)
|
|
((node-is "else") parent-bol 0)
|
|
((node-is "]") parent-bol 0)
|
|
((and (parent-is "comment") c-ts-common-looking-at-star)
|
|
c-ts-common-comment-start-after-first-star -1)
|
|
((parent-is "comment") prev-adaptive-prefix 0)
|
|
(java-ts-mode--first-line-on-multi-line-string parent-bol
|
|
java-ts-mode-indent-offset)
|
|
((parent-is "multiline_string_fragment") prev-adaptive-prefix 0)
|
|
((match "\"\"\"" "string_literal" nil 1) prev-adaptive-prefix 0)
|
|
((parent-is "text_block") no-indent)
|
|
((parent-is "class_body") column-0 c-ts-common-statement-offset)
|
|
((parent-is "array_initializer") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "annotation_type_body") column-0 c-ts-common-statement-offset)
|
|
((parent-is "interface_body") column-0 c-ts-common-statement-offset)
|
|
((parent-is "constructor_body") standalone-parent java-ts-mode-indent-offset)
|
|
((parent-is "enum_body_declarations") parent-bol 0)
|
|
((parent-is "enum_body") column-0 c-ts-common-statement-offset)
|
|
((parent-is "switch_block") standalone-parent java-ts-mode-indent-offset)
|
|
((parent-is "record_declaration_body") column-0 c-ts-common-statement-offset)
|
|
((query "(method_declaration (block _ @indent))") parent-bol java-ts-mode-indent-offset)
|
|
((query "(method_declaration (block (_) @indent))") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "local_variable_declaration") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "expression_statement") parent-bol java-ts-mode-indent-offset)
|
|
((match "type_identifier" "field_declaration") parent-bol 0)
|
|
((parent-is "field_declaration") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "return_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "variable_declarator") parent-bol java-ts-mode-indent-offset)
|
|
((match ">" "type_arguments") parent-bol 0)
|
|
((parent-is "type_arguments") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "method_invocation") parent-bol java-ts-mode-method-chaining-indent-offset)
|
|
((parent-is "switch_rule") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "switch_label") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "ternary_expression") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "lambda_expression") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "element_value_array_initializer") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "function_definition") parent-bol 0)
|
|
((parent-is "conditional_expression") first-sibling 0)
|
|
((parent-is "assignment_expression") parent-bol 2)
|
|
((parent-is "binary_expression") parent 0)
|
|
((parent-is "parenthesized_expression") first-sibling 1)
|
|
((parent-is "argument_list") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "annotation_argument_list") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "modifiers") parent-bol 0)
|
|
;; ((parent-is "formal_parameters") parent-bol java-ts-mode-indent-offset)
|
|
;; ((parent-is "formal_parameter") parent-bol 0)
|
|
((parent-is "init_declarator") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "if_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "for_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "while_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "switch_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "case_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "labeled_statement") parent-bol java-ts-mode-indent-offset)
|
|
((parent-is "do_statement") parent-bol java-ts-mode-indent-offset)
|
|
;; ((parent-is "block") standalone-parent java-ts-mode-indent-offset)
|
|
c-ts-common-baseline-indent-rule))
|
|
"Tree-sitter indent rules.")
|
|
|
|
(defvar java-ts-mode--keywords
|
|
'("abstract" "assert" "break"
|
|
"case" "catch" "class" "continue" "default" "do"
|
|
"else" "enum" "exports" "extends" "final" "finally"
|
|
"for" "if" "implements" "import" "instanceof"
|
|
"interface" "long" "module" "native" "new" "non-sealed"
|
|
"open" "opens" "package" "permits" "private" "protected"
|
|
"provides" "public" "record" "requires" "return" "sealed"
|
|
"short" "static" "strictfp" "switch" "synchronized"
|
|
"throw" "throws" "to" "transient" "transitive" "try"
|
|
"uses" "volatile" "when" "while" "with" "yield")
|
|
"Java keywords for tree-sitter font-locking.")
|
|
|
|
(defvar java-ts-mode--operators
|
|
'("+" ":" "++" "-" "--" "&" "&&" "|" "||" "="
|
|
"!=" "==" "*" "/" "%" "<" "<=" ">" ">="
|
|
"-=" "+=" "*=" "/=" "%=" "->" "^" "^="
|
|
"|=" "~" ">>" ">>>" "<<" "::" "?" "&=")
|
|
"Java operators for tree-sitter font-locking.")
|
|
|
|
(defun java-ts-mode--string-highlight-helper ()
|
|
"Return, for strings, a query based on what is supported by
|
|
the available version of Tree-sitter for Java."
|
|
(condition-case nil
|
|
(progn (treesit-query-capture 'java '((text_block) @font-lock-string-face))
|
|
`((string_literal) @font-lock-string-face
|
|
(text_block) @font-lock-string-face))
|
|
(error
|
|
`((string_literal) @font-lock-string-face))))
|
|
|
|
(defun java-ts-mode--fontify-constant (node override start end &rest _)
|
|
"Fontify a Java constant.
|
|
In Java the names of variables declared class constants and of ANSI
|
|
constants should be all uppercase with words separated by underscores.
|
|
This function also prevents annotations from being highlighted as if
|
|
they were constants.
|
|
For NODE, OVERRIDE, START, and END, see `treesit-font-lock-rules'."
|
|
(let ((node-start (treesit-node-start node))
|
|
(case-fold-search nil))
|
|
(when (and
|
|
(not (equal (char-before node-start) ?@)) ;; skip annotations
|
|
(string-match "\\`[A-Z_][0-9A-Z_]*\\'" (treesit-node-text node)))
|
|
(treesit-fontify-with-override
|
|
node-start (treesit-node-end node)
|
|
'font-lock-constant-face override
|
|
start end))))
|
|
|
|
(defvar java-ts-mode--font-lock-settings
|
|
(treesit-font-lock-rules
|
|
:language 'java
|
|
:override t
|
|
:feature 'comment
|
|
`((line_comment) @font-lock-comment-face
|
|
(block_comment) @font-lock-comment-face)
|
|
:language 'java
|
|
:override t
|
|
:feature 'keyword
|
|
`([,@java-ts-mode--keywords
|
|
(this)
|
|
(super)] @font-lock-keyword-face
|
|
(labeled_statement
|
|
(identifier) @font-lock-keyword-face))
|
|
:language 'java
|
|
:override t
|
|
:feature 'operator
|
|
`([,@java-ts-mode--operators] @font-lock-operator-face
|
|
"@" @font-lock-constant-face)
|
|
:language 'java
|
|
:override t
|
|
:feature 'annotation
|
|
`((annotation
|
|
name: (identifier) @font-lock-constant-face)
|
|
|
|
(marker_annotation
|
|
name: (identifier) @font-lock-constant-face))
|
|
:language 'java
|
|
:override t
|
|
:feature 'string
|
|
(java-ts-mode--string-highlight-helper)
|
|
:language 'java
|
|
:override t
|
|
:feature 'literal
|
|
`((null_literal) @font-lock-constant-face
|
|
(binary_integer_literal) @font-lock-number-face
|
|
(decimal_integer_literal) @font-lock-number-face
|
|
(hex_integer_literal) @font-lock-number-face
|
|
(octal_integer_literal) @font-lock-number-face
|
|
(decimal_floating_point_literal) @font-lock-number-face
|
|
(hex_floating_point_literal) @font-lock-number-face)
|
|
:language 'java
|
|
:override t
|
|
:feature 'type
|
|
'((annotation_type_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(interface_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(class_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(record_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(enum_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(constructor_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(compact_constructor_declaration
|
|
name: (identifier) @font-lock-type-face)
|
|
|
|
(field_access
|
|
object: (identifier) @font-lock-type-face)
|
|
|
|
(method_reference (identifier) @font-lock-type-face)
|
|
|
|
(scoped_identifier (identifier) @font-lock-constant-face)
|
|
|
|
((scoped_identifier name: (identifier) @font-lock-type-face)
|
|
(:match "\\`[A-Z]" @font-lock-type-face))
|
|
|
|
(type_identifier) @font-lock-type-face
|
|
|
|
[(boolean_type)
|
|
(integral_type)
|
|
(floating_point_type)
|
|
(void_type)] @font-lock-type-face)
|
|
:language 'java
|
|
:override t
|
|
:feature 'definition
|
|
`((annotation_type_element_declaration
|
|
name: (identifier) @font-lock-function-name-face)
|
|
|
|
(method_declaration
|
|
name: (identifier) @font-lock-function-name-face)
|
|
|
|
(variable_declarator
|
|
name: (identifier) @font-lock-variable-name-face)
|
|
|
|
(element_value_pair
|
|
key: (identifier) @font-lock-property-use-face)
|
|
|
|
(formal_parameter
|
|
name: (identifier) @font-lock-variable-name-face)
|
|
|
|
(catch_formal_parameter
|
|
name: (identifier) @font-lock-variable-name-face))
|
|
:language 'java
|
|
:override t
|
|
:feature 'expression
|
|
'((method_invocation
|
|
object: (identifier) @font-lock-variable-use-face)
|
|
|
|
(method_invocation
|
|
name: (identifier) @font-lock-function-call-face)
|
|
|
|
(argument_list (identifier) @font-lock-variable-name-face)
|
|
|
|
(expression_statement (identifier) @font-lock-variable-use-face))
|
|
;; Make sure the constant feature is after expression and definition,
|
|
;; because those two applies variable-name-face on some constants.
|
|
:language 'java
|
|
:override t
|
|
:feature 'constant
|
|
`((identifier) @java-ts-mode--fontify-constant
|
|
[(true) (false)] @font-lock-constant-face)
|
|
:language 'java
|
|
:feature 'bracket
|
|
'((["(" ")" "[" "]" "{" "}"]) @font-lock-bracket-face)
|
|
|
|
:language 'java
|
|
:feature 'delimiter
|
|
'((["," ":" ";"]) @font-lock-delimiter-face))
|
|
"Tree-sitter font-lock settings for `java-ts-mode'.")
|
|
|
|
(defun java-ts-mode--defun-name (node)
|
|
"Return the defun name of NODE.
|
|
Return nil if there is no name or if NODE is not a defun node."
|
|
(pcase (treesit-node-type node)
|
|
((or "method_declaration"
|
|
"class_declaration"
|
|
"record_declaration"
|
|
"interface_declaration"
|
|
"enum_declaration"
|
|
"import_declaration"
|
|
"package_declaration"
|
|
"module_declaration")
|
|
(treesit-node-text
|
|
(treesit-node-child-by-field-name node "name")
|
|
t))))
|
|
|
|
|
|
(defvar java-ts-mode--feature-list
|
|
'(( comment document definition )
|
|
( constant keyword string type)
|
|
( annotation expression literal)
|
|
( bracket delimiter operator)))
|
|
|
|
;;;###autoload
|
|
(define-derived-mode java-ts-mode prog-mode "Java"
|
|
"Major mode for editing Java, powered by tree-sitter."
|
|
:group 'java
|
|
:syntax-table java-ts-mode--syntax-table
|
|
|
|
(unless (treesit-ensure-installed 'java)
|
|
(error "Tree-sitter for Java isn't available"))
|
|
|
|
(let ((primary-parser (treesit-parser-create 'java)))
|
|
|
|
;; Comments.
|
|
(c-ts-common-comment-setup)
|
|
|
|
;; Indent.
|
|
(setq-local c-ts-common-indent-type-regexp-alist
|
|
`((block . ,(rx (or "class_body"
|
|
"array_initializer"
|
|
"constructor_body"
|
|
"annotation_type_body"
|
|
"interface_body"
|
|
"lambda_expression"
|
|
"enum_body"
|
|
"switch_block"
|
|
"record_declaration_body"
|
|
"block")))
|
|
(close-bracket . "}")
|
|
(if . "if_statement")
|
|
(else . ("if_statement" . "alternative"))
|
|
(for . "for_statement")
|
|
(while . "while_statement")
|
|
(do . "do_statement")))
|
|
(setq-local c-ts-common-indent-offset 'java-ts-mode-indent-offset)
|
|
(setq-local treesit-simple-indent-rules java-ts-mode--indent-rules)
|
|
(setq-local treesit-simple-indent-standalone-predicate
|
|
#'java-ts-mode--standalone-predicate)
|
|
(setq-local c-ts-common-list-indent-style 'simple)
|
|
|
|
;; Electric
|
|
(setq-local electric-indent-chars
|
|
(append "{}():;," electric-indent-chars))
|
|
|
|
;; Navigation.
|
|
(setq-local treesit-defun-type-regexp
|
|
(regexp-opt '("method_declaration"
|
|
"class_declaration"
|
|
"record_declaration"
|
|
"interface_declaration"
|
|
"enum_declaration"
|
|
"import_declaration"
|
|
"package_declaration"
|
|
"module_declaration"
|
|
"constructor_declaration")))
|
|
(setq-local treesit-defun-name-function #'java-ts-mode--defun-name)
|
|
|
|
(setq-local treesit-thing-settings
|
|
`((java
|
|
(sexp (not (or (and named
|
|
,(rx bos (or "program"
|
|
"line_comment"
|
|
"block_comment")
|
|
eos))
|
|
(and anonymous
|
|
,(rx (or "{" "}" "[" "]"
|
|
"(" ")" "<" ">"
|
|
","))))))
|
|
(list ,(rx bos (or "inferred_parameters"
|
|
"parenthesized_expression"
|
|
"argument_list"
|
|
"type_arguments"
|
|
"switch_block"
|
|
"record_pattern_body"
|
|
"block"
|
|
"resource_specification"
|
|
"annotation_argument_list"
|
|
"element_value_array_initializer"
|
|
"module_body"
|
|
"enum_body"
|
|
"type_parameters"
|
|
"class_body"
|
|
"constructor_body"
|
|
"annotation_type_body"
|
|
"interface_body"
|
|
"array_initializer"
|
|
"formal_parameters")
|
|
eos))
|
|
(sentence ,(rx (or "statement"
|
|
"local_variable_declaration"
|
|
"field_declaration"
|
|
"module_declaration"
|
|
"package_declaration"
|
|
"import_declaration")))
|
|
(text ,(regexp-opt '("line_comment"
|
|
"block_comment"
|
|
"text_block"))))))
|
|
|
|
;; Font-lock.
|
|
(setq-local treesit-font-lock-settings
|
|
java-ts-mode--font-lock-settings)
|
|
|
|
;; Inject doxygen parser for comment.
|
|
(when (and java-ts-mode-enable-doxygen
|
|
(treesit-ensure-installed 'doxygen))
|
|
(setq-local treesit-primary-parser primary-parser)
|
|
(setq-local treesit-font-lock-settings
|
|
(append treesit-font-lock-settings
|
|
c-ts-mode-doxygen-comment-font-lock-settings))
|
|
(setq-local treesit-range-settings
|
|
(treesit-range-rules
|
|
:embed 'doxygen
|
|
:host 'java
|
|
:local t
|
|
`(((block_comment) @cap (:match "/\\*\\*" @cap)))))))
|
|
|
|
(setq-local treesit-font-lock-feature-list java-ts-mode--feature-list)
|
|
|
|
;; Imenu.
|
|
(setq-local treesit-simple-imenu-settings
|
|
'(("Class" "\\`class_declaration\\'" nil nil)
|
|
("Interface" "\\`interface_declaration\\'" nil nil)
|
|
("Enum" "\\`record_declaration\\'" nil nil)
|
|
("Method" "\\`method_declaration\\'" nil nil)))
|
|
;; Outline minor mode
|
|
(setq-local treesit-outline-predicate
|
|
(rx bos (or "class_declaration"
|
|
"interface_declaration"
|
|
"method_declaration"
|
|
"constructor_declaration")
|
|
eos))
|
|
|
|
(treesit-major-mode-setup))
|
|
|
|
(derived-mode-add-parents 'java-ts-mode '(java-mode))
|
|
|
|
(if (treesit-ready-p 'java)
|
|
(add-to-list 'auto-mode-alist '("\\.java\\'" . java-ts-mode)))
|
|
|
|
(provide 'java-ts-mode)
|
|
|
|
;;; java-ts-mode.el ends here
|