kotlin-mode.el

;;; kotlin-mode.el --- Major mode for kotlin -*- lexical-binding: t; -*-

;; Copyright © 2015  Shodai Yokoyama

;; Author: Shodai Yokoyama (quantumcars@gmail.com)
;; Keywords: languages
;; Package-Requires: ((emacs "24.3"))

;; This program 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.

;; This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;

;;; Code:

(require 'comint)
(require 'rx)
(require 'cc-cmds)
(require 'cl-lib)
(require 'eieio)

(require 'kotlin-mode-lexer)

(defgroup kotlin nil
  "A Kotlin major mode."
  :group 'languages)

(defcustom kotlin-tab-width 4
  "The tab width to use for indentation."
  :type 'integer
  :group 'kotlin-mode
  :safe 'integerp)

(defcustom kotlin-command "kotlinc"
  "The Kotlin command used for evaluating code."
  :type 'string
  :group 'kotlin)

(defcustom kotlin-args-repl '()
  "The arguments to pass to `kotlin-command' to start a REPL."
  :type 'list
  :group 'kotlin)

(defcustom kotlin-repl-buffer "*KotlinREPL*"
  "The name of the KotlinREPL buffer."
  :type 'string
  :group 'kotlin)

(defun kotlin-do-and-repl-focus (f &rest args)
  (apply f args)
  (pop-to-buffer kotlin-repl-buffer))

(defun kotlin-send-region (start end)
  "Send current region to Kotlin interpreter."
  (interactive "r")
  (comint-send-region kotlin-repl-buffer start end)
  (comint-send-string kotlin-repl-buffer "\n"))

(defun kotlin-send-region-and-focus (start end)
  "Send current region to Kotlin interpreter and switch to it."
  (interactive "r")
  (kotlin-do-and-repl-focus 'kotlin-send-region start end))

(defun kotlin-send-buffer ()
  "Send whole buffer to Kotlin interpreter."
  (interactive)
  (kotlin-send-region (point-min) (point-max)))

(defun kotlin-send-buffer-and-focus ()
  "Send whole buffer to Kotlin interpreter and switch to it."
  (interactive)
  (kotlin-do-and-repl-focus 'kotlin-send-buffer))

(defun kotlin-send-block ()
  "Send block to Kotlin interpreter."
  (interactive)
  (save-mark-and-excursion
    (mark-paragraph)
    (kotlin-send-region (region-beginning) (region-end))))

(defun kotlin-send-block-and-focus ()
  "Send block to Kotlin interpreter and switch to it."
  (interactive)
  (kotlin-do-and-repl-focus 'kotlin-send-block))

(defun kotlin-send-line ()
  (interactive)
  (kotlin-send-region
   (line-beginning-position)
   (line-end-position)))

(defun kotlin-send-line-and-focus ()
  "Send current line to Kotlin interpreter and switch to it."
  (interactive)
  (kotlin-do-and-repl-focus 'kotlin-send-line))

(defun kotlin-repl ()
  "Launch a Kotlin REPL using `kotlin-command' as an inferior mode."
  (interactive)

  (unless (comint-check-proc kotlin-repl-buffer)
    (set-buffer
     (apply 'make-comint "KotlinREPL"
            "env"
            nil
            "NODE_NO_READLINE=1"
            kotlin-command
            kotlin-args-repl))

    (set (make-local-variable 'comint-preoutput-filter-functions)
         (cons (lambda (string)
                 (replace-regexp-in-string "\x1b\\[.[GJK]" "" string)) nil)))

  (pop-to-buffer kotlin-repl-buffer))

(defvar kotlin-mode-map
  (let ((map (make-keymap)))
    (define-key map (kbd "C-c C-z") 'kotlin-repl)
    (define-key map (kbd "C-c C-n") 'kotlin-send-line)
    (define-key map (kbd "C-c C-r") 'kotlin-send-region)
    (define-key map (kbd "C-c C-c") 'kotlin-send-block)
    (define-key map (kbd "C-c C-b") 'kotlin-send-buffer)
    map)
  "Keymap for kotlin-mode")

(defvar kotlin-mode-syntax-table
  (let ((st (make-syntax-table)))

    ;; Strings
    (modify-syntax-entry ?\" "\"" st)
    (modify-syntax-entry ?\' "\"" st)
    (modify-syntax-entry ?` "\"" st)

    ;; `_' as being a valid part of a word
    (modify-syntax-entry ?_ "w" st)

    ;; b-style comment
    (modify-syntax-entry ?/ ". 124b" st)
    (modify-syntax-entry ?* ". 23n" st)
    (modify-syntax-entry ?\n "> b" st)
    (modify-syntax-entry ?\r "> b" st)
    st))


;;; Font Lock

(defconst kotlin-mode--misc-keywords
  '("package" "import"))

(defconst kotlin-mode--type-decl-keywords
  '("sealed" "inner" "data" "class" "interface" "trait" "typealias" "enum" "object"))

(defconst kotlin-mode--fun-decl-keywords
  '("fun"))

(defconst kotlin-mode--val-decl-keywords
  '("val" "var"))

(defconst kotlin-mode--statement-keywords
  '(;; Branching
    "if" "else"
    ;; Exceptions
    "try" "catch" "finally" "throw"
    ;; Loops
    "while" "for" "do" "continue" "break"
    ;; Miscellaneous
    "when" "is" "in" "as" "return"))

(defconst kotlin-mode--context-variables-keywords
  '("field" "it" "this" "super"))

(defconst kotlin-mode--generic-type-parameter-keywords
  '("where"))

(defvar kotlin-mode--keywords
  (append kotlin-mode--misc-keywords
          kotlin-mode--type-decl-keywords
          kotlin-mode--fun-decl-keywords
          kotlin-mode--val-decl-keywords
          kotlin-mode--statement-keywords
          kotlin-mode--context-variables-keywords
          kotlin-mode--generic-type-parameter-keywords)
  "Keywords used in Kotlin language.")

(defconst kotlin-mode--constants-keywords
  '("null" "true" "false"))

(defconst kotlin-mode--modifier-keywords
  '("open" "private" "protected" "public" "lateinit"
    "override" "abstract" "final" "companion"
    "annotation" "internal" "const" "in" "out"
    "actual" "expect" "crossinline" "inline" "noinline" "external"
    "infix" "operator" "reified" "suspend" "tailrec" "vararg"))

(defconst kotlin-mode--property-keywords
  '("by" "get" "set")) ;; "by" "get" "set"

(defconst kotlin-mode--initializer-keywords
  '("init" "constructor"))

(defconst kotlin-mode--annotation-use-site-target-keywords
  '("delegate" "field" "file" "get" "param" "property" "receiver" "set"
    "setparam"))

(defconst kotlin-mode--type-keywords
  '("dynamic"))

(defvar kotlin-mode--font-lock-keywords
  `(;; Keywords
    (,(rx-to-string
       `(and bow (group (or ,@kotlin-mode--keywords)) eow)
       t)
     1 font-lock-keyword-face)

    ;; Package names
    (,(rx-to-string
       `(and (or ,@kotlin-mode--misc-keywords) (+ space)
             (group (+ (any word ?.))))
       t)
     1 font-lock-string-face)

    ;; Types
    (,(rx-to-string
       `(and bow upper (group (* (or word "<" ">" "." "?" "!" "*"))))
       t)
     0 font-lock-type-face)

    (,(rx-to-string
       `(and bow (or ,@kotlin-mode--type-keywords) eow)
       t)
     0 font-lock-type-face)

    ;; Classes/Enums
    (,(rx-to-string
       `(and bow (or ,@kotlin-mode--type-decl-keywords) eow (+ space)
             (group (+ word)) eow)
       t)
     1 font-lock-type-face)

    ;; Constants
    (,(rx-to-string
       `(and bow (group (or ,@kotlin-mode--constants-keywords)) eow)
       t)
     0 font-lock-constant-face)

    ;; Value bindings
    (,(rx-to-string
       `(and bow (or ,@kotlin-mode--val-decl-keywords) eow
             (+ space)
             (group (+ word)) (* space)  (\? ":"))
       t)
     1 font-lock-variable-name-face t)

    ;; Function names
    (,(rx-to-string
       `(and (or ,@kotlin-mode--fun-decl-keywords)
             (+ space) bow (group (+ (any alnum word))) eow)
       t)
     1 font-lock-function-name-face)

    ;; Access modifier
    ;; Access modifier is valid identifier being used as variable
    ;; TODO: Highlight only modifiers in the front of class/fun
    (,(rx-to-string
       `(and bow (group (or ,@kotlin-mode--modifier-keywords))
             eow)
       t)
     1 font-lock-keyword-face)

    ;; Properties
    ;; by/get/set are valid identifiers being used as variable
    ;; TODO: Highlight only within the property declaration statement
    (,(rx-to-string
       `(and bow (group (or ,@kotlin-mode--property-keywords)) eow)
       t)
     1 font-lock-keyword-face)

    ;; Constructor/Initializer blocks
    (,(rx-to-string
       `(and bow (group (or ,@kotlin-mode--initializer-keywords)) eow)
       t)
     1 font-lock-keyword-face)

    ;; Annotation use-site targets
    (,(rx-to-string
       `(and "@"
             (group (or ,@kotlin-mode--annotation-use-site-target-keywords))
             eow)
       t)
     1 font-lock-keyword-face)

    ;; Labels
    (,(rx-to-string
       `(and bow (group (+ word)) "@")
       t)
     1 font-lock-constant-face)

    ;; String interpolation
    (kotlin-mode--match-interpolation 0 font-lock-variable-name-face t))
  "Default highlighting expression for `kotlin-mode'")

(defun kotlin-mode--match-interpolation (limit)
  (let ((pos (next-single-char-property-change
              (point)
              'kotlin-property--interpolation
              nil
              limit)))
    (when (and pos (> pos (point)))
      (goto-char pos)
      (let ((value (get-text-property pos 'kotlin-property--interpolation)))
        (if value
            (progn (set-match-data value)
                   t)
          (kotlin-mode--match-interpolation limit))))))

(defun kotlin-mode--prev-line ()
  "Moves up to the nearest non-empty line"
  (if (not (bobp))
      (progn
        (forward-line -1)
        (while (and (looking-at "^[ \t]*$") (not (bobp)))
          (forward-line -1)))))

(defun kotlin-mode--line-begins (pattern)
  "Return whether the current line begins with the given pattern"
  (save-excursion
    (beginning-of-line)
    (looking-at (format "^[ \t]*%s" pattern))))

(defun kotlin-mode--line-ends (pattern)
  "Return whether the current line ends with the given pattern"
  (save-excursion
    (beginning-of-line)
    (looking-at (format ".*%s[ \t]*$" pattern))))

(defun kotlin-mode--line-contains (pattern)
  "Return whether the current line contains the given pattern"
  (save-excursion
    (beginning-of-line)
    (looking-at (format ".*%s.*" pattern))))

(defun kotlin-mode--line-continuation()
  "Return whether this line continues a statement in the previous line"
  (or
   (kotlin-mode--line-begins "\\([.=:]\\|->\\|[sg]et\\b\\)")
   (save-excursion
     (kotlin-mode--prev-line)
     (kotlin-mode--line-ends "\\([=:]\\|->\\)"))))

(defun kotlin-mode--base-indentation ()
  "Return the indentation level of the current line based on brackets only,
   i.e. ignoring 'continuation' indentation."
  (cond ((kotlin-mode--line-continuation)
         (- (current-indentation) kotlin-tab-width))
        ((kotlin-mode--in-comment-block)
         (- (current-indentation) 1))
        (t
         (current-indentation))))

(defclass kotlin-mode--bracket-counter ()
  ((count :initarg :count
          :initform 0
          :type integer
          :documentation "The net bracket count (+1 for open, -1 for close).")
   (indent :initarg :indent
           :initform 0
           :type integer
           :documentation "The indentation based on bracket layout.")
   (finished :initarg :finished
             :initform nil
             :type boolean
             :documentation "Whether the counting has finished.")
   (use-base :initarg :use-base
             :initform t
             :type boolean
             :documentation "Whether to factor out extra indentations."))
  "A class for counting brackets to find the appropriate bracket-based indent.
   The logic here involves keeping track of the net-bracket-count,
   defined as the number of open-brackets minus the number of close-brackets.
   We scroll backwards until the net-bracket-count is zero, and this point
   determines the desired indentation level for the current line.")

(defun kotlin-mode--count-to-line-start (counter)
  "Count the brackets on the current line, starting from the
cursor position, and working backward, incrementing the count +1
for open-brackets, -1 for close-brackets.

Mark the COUNTER finished, set indentation, and return as soon as
the overall count exceeds zero.  If the counter is zero at the
beginning of the line, Mark the counter finished and set
indentation.  If we hit a beginning of line but the counter is
negative, just return without marking finished."
  (when (nth 4 (syntax-ppss))
    ;; If the point is inside a comment, goto the beginning of the comment.
    (goto-char (nth 8 (syntax-ppss))))
  (save-excursion
    (let ((line-beginning-position (line-beginning-position)))
      (while (and (<= (oref counter count) 0) (not (bolp)))
        (forward-comment (- (point)))
        (backward-char)
        (when (< (point) line-beginning-position)
          (goto-char line-beginning-position))
        (cond ((eq (char-syntax (char-after)) ?\()
               (cl-incf (oref counter count)))
              ((eq (char-syntax (char-after)) ?\))
               (cl-decf (oref counter count))))))
    ;; We are at the beginning of the line, or just before an
    ;; unmatching open bracket.
    (cond
     ;; If the net-bracket-count is zero, use this indentation
     ((= (oref counter count) 0)
      (oset counter finished t)
      (if (oref counter use-base)
          ;; Indenting a line that is neither close bracket nor the
          ;; first element of a block or a list.  Found the previous
          ;; line.  So align with the previous line, without effect of
          ;; continued expression at the previous line.
          (kotlin-mode--add-indent counter (kotlin-mode--base-indentation))
        ;; Indenting close bracket or the first element of a block or
        ;; a list.  So align with this line, optionally with extra
        ;; indentation.
        (kotlin-mode--add-indent counter (current-indentation))))
     ;; If we've now counted more open-brackets than close-brackets,
     ;; use the indentation of the content immediately following the
     ;; final open-bracket.
     ;;
     ;; Example:
     ;;
     ;; Suppose indenting "bar2()" in the following example:
     ;;
     ;; foo(  bar1(),
     ;;       bar2())
     ;;
     ;; We are at just before the open bracket of "foo".  So skip the
     ;; open bracket and spaces, then align "bar2()" with "bar1()".
     ((> (oref counter count) 0)
      (oset counter finished t)
      (forward-char)
      (skip-syntax-forward "(")
      (skip-syntax-forward "-")
      (kotlin-mode--add-indent counter (current-column))))))

(defun kotlin-mode--count-leading-close-brackets (counter)
  "Adjust COUNTER when indenting close brackets.

This function should be called at the line being indented.

Example:
Suppose indenting the closing bracket of \"bar\" in the following example:

fun foo() {
    bar {
      baz()
    } // Indenting here
}

This function decrements the counter, so that
`kotlin-mode--count-to-line-start' should not stop at the line
\"baz()\", but goto the line \"bar {\", so that the close bracket
aligned with \"bar {\"."

  (save-excursion
    (skip-syntax-forward "-")
    (when (looking-at "\\s)")
      (oset counter use-base nil)
      (kotlin-mode--subtract-count counter (skip-syntax-forward ")")))))

(defun kotlin-mode--count-trailing-open-brackets (counter)
  "Adjust COUNTER when indenting the first element of a block or list.

This function should be called before calling
`kotlin-mode--count-to-line-start', with the point at the end of
the previous line of the line being indented.

If the bracket count is at zero, and there are open-brackets at
the end of the line, do not count them, but add a single
indentation level. If bracket count is at zero, we are not
indenting close brackets.

Example:

Suppose indenting \"baz()\" in the following example:

fun foo() {
    bar {
        baz()
    }
}

This function is called with the point at the end of the line
\"bar {\". This function skips \"{\" backward and add indentation
amount `kotlin-tab-width', say 4.  Then
`kotlin-mode--count-to-line-start' seeks to the
beginning-of-line.  So the final indentation is 8, that is the
sum of indentation of bar and extra indentation.

On the other hand, when indenting \"baz2()\" in the following
line, keep cursor and indentation level as is because
\"bar(baz1(),\" does not end with open brackets.  Then
`kotlin-mode--count-to-line-start' stops at the close bracket of
\"bar(\".  So \"baz2()\" is aligned with \"baz1()\".

fun foo() {
    bar(baz1(),
        baz2())
}"
  (when (and (= (oref counter count) 0)
             (not (= (skip-syntax-backward "(") 0)))
    (kotlin-mode--add-indent counter kotlin-tab-width)
    (oset counter use-base nil)))

(defun kotlin-mode--add-count (counter val)
  (cl-incf (oref counter count) val))

(defun kotlin-mode--subtract-count (counter val)
  (cl-decf (oref counter count) val))

(defun kotlin-mode--add-indent (counter val)
  (cl-incf (oref counter indent) val))

(defun kotlin-mode--finished (counter)
  (oref counter finished))

(defun kotlin-mode--in-comment-block ()
  "Return whether the cursor is within a standard comment block structure
   of the following format:
   /**
    * Description here
    */"
  (save-excursion
    (let ((in-comment-block nil)
          (keep-going (and
                       (not (kotlin-mode--line-begins "\\*\\*+/"))
                       (not (kotlin-mode--line-begins "/\\*"))
                       (nth 4 (syntax-ppss)))))
      (while keep-going
        (kotlin-mode--prev-line)
        (cond
         ((kotlin-mode--line-begins "/\\*")
          (setq keep-going nil)
          (setq in-comment-block t))
         ((bobp)
          (setq keep-going nil))
         ((kotlin-mode--line-contains "\\*/")
          (setq keep-going nil))))
      in-comment-block)))

(defun kotlin-mode--indent-line ()
  "Indent current line as kotlin code."
  (interactive)
  (beginning-of-line)
  (if (bobp)
      (kotlin-mode--beginning-of-buffer-indent)
    (let* ((bracket-counter (make-instance 'kotlin-mode--bracket-counter))
           ;; Find bracket-based indentation first
           (cur-indent
            (progn
              (kotlin-mode--count-leading-close-brackets bracket-counter)
              (save-excursion
                (kotlin-mode--prev-line)
                (end-of-line)
                (kotlin-mode--count-trailing-open-brackets bracket-counter)
                (kotlin-mode--count-to-line-start bracket-counter)
                (while (and (not (kotlin-mode--finished bracket-counter))
                            (not (bobp)))
                  (kotlin-mode--prev-line)
                  (end-of-line)
                  (kotlin-mode--count-to-line-start bracket-counter))
                (oref bracket-counter indent)))))

      (cond
       ((kotlin-mode--line-continuation)
        ;; Add extra indentation if the line continues the previous one
        (cl-incf cur-indent kotlin-tab-width))

       ((kotlin-mode--in-comment-block)
        ;; Add one space of extra indentation if inside a comment block
        (cl-incf cur-indent)))

      (indent-line-to cur-indent))))

(defun kotlin-mode--beginning-of-buffer-indent ()
  (indent-line-to 0))

;;;###autoload
(define-derived-mode kotlin-mode prog-mode "Kotlin"
  "Major mode for editing Kotlin."

  (setq font-lock-defaults '((kotlin-mode--font-lock-keywords) nil nil))
  (setq-local parse-sexp-lookup-properties t)
  (add-hook 'syntax-propertize-extend-region-functions
            #'kotlin-mode--syntax-propertize-extend-region
            nil t)
  (setq-local syntax-propertize-function #'kotlin-mode--syntax-propertize)
  (set (make-local-variable 'comment-start) "//")
  (set (make-local-variable 'comment-padding) 1)
  (set (make-local-variable 'comment-start-skip) "\\(//+\\|/\\*+\\)\\s *")
  (set (make-local-variable 'comment-end) "")
  (set (make-local-variable 'indent-line-function) 'kotlin-mode--indent-line)
  (setq-local adaptive-fill-regexp comment-start-skip)

  :group 'kotlin
  :syntax-table kotlin-mode-syntax-table)

;;;###autoload
(add-to-list 'auto-mode-alist '("\\.kts?\\'" . kotlin-mode) t)

(provide 'kotlin-mode)
;;; kotlin-mode.el ends here