17ee0e400b
After moving off of Meta, Dotfiles has a greater responsibility to manage configs. Vim, Tmux, and Emacs are now within Stow's purview.
393 lines
15 KiB
EmacsLisp
393 lines
15 KiB
EmacsLisp
;;; haskell-completions.el --- Haskell Completion package -*- lexical-binding: t -*-
|
|
|
|
;; Copyright © 2015-2016 Athur Fayzrakhmanov. All rights reserved.
|
|
|
|
;; This file is part of haskell-mode package.
|
|
;; You can contact with authors using GitHub issue tracker:
|
|
;; https://github.com/haskell/haskell-mode/issues
|
|
|
|
;; This file 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, or (at your option)
|
|
;; any later version.
|
|
|
|
;; This file 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; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
;; Boston, MA 02110-1301, USA.
|
|
|
|
;;; Commentary:
|
|
|
|
;; This package provides completions related functionality for
|
|
;; Haskell Mode such grab completion prefix at point, and etc..
|
|
|
|
;; Some description
|
|
;; ================
|
|
;;
|
|
;; For major use function `haskell-completions-grab-prefix' is supposed, and
|
|
;; other prefix grabbing functions are used internally by it. So, only this
|
|
;; funciton have prefix minimal length functionality and invokes predicate
|
|
;; function `haskell-completions-can-grab-prefix'.
|
|
|
|
;;; Code:
|
|
|
|
(require 'haskell-mode)
|
|
(require 'haskell-process)
|
|
(require 'haskell-interactive-mode)
|
|
|
|
;;;###autoload
|
|
(defgroup haskell-completions nil
|
|
"Settings for completions provided by `haskell-mode'"
|
|
:link '(custom-manual "(haskell-mode)Completion support")
|
|
:group 'haskell)
|
|
|
|
(defcustom haskell-completions-complete-operators
|
|
t
|
|
"Should `haskell-completions-sync-repl-completion-at-point' complete operators.
|
|
|
|
Note: GHCi prior to version 8.0.1 have bug in `:complete`
|
|
command: when completing operators it returns a list of all
|
|
imported identifiers (see Track ticket URL
|
|
`https://ghc.haskell.org/trac/ghc/ticket/10576'). This leads to
|
|
significant Emacs slowdown. To aviod slowdown you should set
|
|
this variable to `nil'."
|
|
:group 'haskell-completions
|
|
:type 'boolean)
|
|
|
|
(defvar haskell-completions--pragma-names
|
|
(list "DEPRECATED"
|
|
"INCLUDE"
|
|
"INCOHERENT"
|
|
"INLINABLE"
|
|
"INLINE"
|
|
"LANGUAGE"
|
|
"LINE"
|
|
"MINIMAL"
|
|
"NOINLINE"
|
|
"NOUNPACK"
|
|
"OPTIONS"
|
|
"OPTIONS_GHC"
|
|
"OVERLAPPABLE"
|
|
"OVERLAPPING"
|
|
"OVERLAPS"
|
|
"RULES"
|
|
"SOURCE"
|
|
"SPECIALIZE"
|
|
"UNPACK"
|
|
"WARNING")
|
|
"A list of supported pragmas.
|
|
This list comes from GHC documentation (URL
|
|
`https://downloads.haskell.org/~ghc/7.10.1/docs/html/users_guide/pragmas.html'.")
|
|
|
|
(defvar haskell-completions--keywords
|
|
(list
|
|
"as"
|
|
"case"
|
|
"class"
|
|
"data family"
|
|
"data instance"
|
|
"data"
|
|
"default"
|
|
"deriving instance"
|
|
"deriving"
|
|
"do"
|
|
"else"
|
|
"family"
|
|
"forall"
|
|
"foreign import"
|
|
"foreign"
|
|
"hiding"
|
|
"if"
|
|
"import qualified"
|
|
"import"
|
|
"in"
|
|
"infix"
|
|
"infixl"
|
|
"infixr"
|
|
"instance"
|
|
"let"
|
|
"mdo"
|
|
"module"
|
|
"newtype"
|
|
"of"
|
|
"proc"
|
|
"qualified"
|
|
"rec"
|
|
"signature"
|
|
"then"
|
|
"type family"
|
|
"type instance"
|
|
"type"
|
|
"where")
|
|
"A list of Haskell's keywords (URL `https://wiki.haskell.org/Keywords').
|
|
Single char keywords and operator like keywords are not included
|
|
in this list.")
|
|
|
|
|
|
(defun haskell-completions-can-grab-prefix ()
|
|
"Check if the case is appropriate for grabbing completion prefix.
|
|
Returns t if point is either at whitespace character, or at
|
|
punctuation, or at line end and preceeding character is not a
|
|
whitespace or new line, otherwise returns nil.
|
|
|
|
Returns nil in presence of active region."
|
|
(when (not (region-active-p))
|
|
(when (looking-at-p (rx (| space line-end punct)))
|
|
(when (not (bobp))
|
|
(save-excursion
|
|
(backward-char)
|
|
(not (looking-at-p (rx (| space line-end)))))))))
|
|
|
|
(defun haskell-completions-grab-pragma-prefix ()
|
|
"Grab completion prefix for pragma completions.
|
|
Returns a list of form '(prefix-start-position
|
|
prefix-end-position prefix-value prefix-type) for pramga names
|
|
such as WARNING, DEPRECATED, LANGUAGE etc. Also returns
|
|
completion prefixes for options in case OPTIONS_GHC pragma, or
|
|
language extensions in case of LANGUAGE pragma. Obsolete OPTIONS
|
|
pragma is supported also."
|
|
(when (nth 4 (syntax-ppss))
|
|
;; We're inside comment
|
|
(let ((p (point))
|
|
(comment-start (nth 8 (syntax-ppss)))
|
|
(case-fold-search nil)
|
|
prefix-start
|
|
prefix-end
|
|
prefix-type
|
|
prefix-value)
|
|
(save-excursion
|
|
(goto-char comment-start)
|
|
(when (looking-at (rx "{-#" (1+ (| space "\n"))))
|
|
(let ((pragma-start (match-end 0)))
|
|
(when (> p pragma-start)
|
|
;; point stands after `{-#`
|
|
(goto-char pragma-start)
|
|
(when (looking-at (rx (1+ (| upper "_"))))
|
|
;; found suitable sequence for pragma name
|
|
(let ((pragma-end (match-end 0))
|
|
(pragma-value (match-string-no-properties 0)))
|
|
(if (eq p pragma-end)
|
|
;; point is at the end of (in)complete pragma name
|
|
;; prepare resulting values
|
|
(progn
|
|
(setq prefix-start pragma-start)
|
|
(setq prefix-end pragma-end)
|
|
(setq prefix-value pragma-value)
|
|
(setq prefix-type
|
|
'haskell-completions-pragma-name-prefix))
|
|
(when (and (> p pragma-end)
|
|
(or (equal "OPTIONS_GHC" pragma-value)
|
|
(equal "OPTIONS" pragma-value)
|
|
(equal "LANGUAGE" pragma-value)))
|
|
;; point is after pragma name, so we need to check
|
|
;; special cases of `OPTIONS_GHC` and `LANGUAGE` pragmas
|
|
;; and provide a completion prefix for possible ghc
|
|
;; option or language extension.
|
|
(goto-char pragma-end)
|
|
(when (re-search-forward
|
|
(rx (* anything)
|
|
(1+ (regexp "\\S-")))
|
|
p
|
|
t)
|
|
(let* ((str (match-string-no-properties 0))
|
|
(split (split-string str (rx (| space "\n")) t))
|
|
(val (car (last split)))
|
|
(end (point)))
|
|
(when (and (equal p end)
|
|
(not (string-match-p "#" val)))
|
|
(setq prefix-value val)
|
|
(backward-char (length val))
|
|
(setq prefix-start (point))
|
|
(setq prefix-end end)
|
|
(setq
|
|
prefix-type
|
|
(if (not (equal "LANGUAGE" pragma-value))
|
|
'haskell-completions-ghc-option-prefix
|
|
'haskell-completions-language-extension-prefix
|
|
)))))))))))))
|
|
(when prefix-value
|
|
(list prefix-start prefix-end prefix-value prefix-type)))))
|
|
|
|
(defun haskell-completions-grab-identifier-prefix ()
|
|
"Grab completion prefix for identifier at point.
|
|
Returns a list of form '(prefix-start-position
|
|
prefix-end-position prefix-value prefix-type) for haskell
|
|
identifier at point depending on result of function
|
|
`haskell-ident-pos-at-point'."
|
|
(let ((pos-at-point (haskell-ident-pos-at-point))
|
|
(p (point)))
|
|
(when pos-at-point
|
|
(let* ((start (car pos-at-point))
|
|
(end (cdr pos-at-point))
|
|
(type 'haskell-completions-identifier-prefix)
|
|
(case-fold-search nil)
|
|
value)
|
|
;; we need end position of result, becase of
|
|
;; `haskell-ident-pos-at-point' ignores trailing whitespace, e.g. the
|
|
;; result will be same for `map|` and `map |` invocations.
|
|
(when (<= p end)
|
|
(setq end p)
|
|
(setq value (buffer-substring-no-properties start end))
|
|
(when (string-match-p (rx bos upper) value)
|
|
;; we need to check if found identifier is a module name
|
|
(save-excursion
|
|
(goto-char (line-beginning-position))
|
|
(when (re-search-forward
|
|
(rx "import"
|
|
(? (1+ space) "qualified")
|
|
(1+ space)
|
|
upper
|
|
(1+ (| alnum ".")))
|
|
p ;; bound
|
|
t) ;; no-error
|
|
(if (equal p (point))
|
|
(setq type 'haskell-completions-module-name-prefix)
|
|
(when (re-search-forward
|
|
(rx (| " as " "("))
|
|
start
|
|
t)
|
|
;; but uppercase ident could occur after `as` keyword, or in
|
|
;; module imports after opening parenthesis, in this case
|
|
;; restore identifier type again, it's neccessary to
|
|
;; distinguish the means of completions retrieval
|
|
(setq type 'haskell-completions-identifier-prefix))))))
|
|
(when (nth 8 (syntax-ppss))
|
|
;; eighth element of syntax-ppss result is string or comment start,
|
|
;; so when it's not nil word at point is inside string or comment,
|
|
;; return special literal prefix type
|
|
(setq type 'haskell-completions-general-prefix))
|
|
;; finally take in account minlen if given and return the result
|
|
(when value (list start end value type)))))))
|
|
|
|
(defun haskell-completions-grab-prefix (&optional minlen)
|
|
"Grab prefix at point for possible completion.
|
|
Returns a list of form '(prefix-start-position
|
|
prefix-end-position prefix-value prefix-type) depending on
|
|
situation, e.g. is it needed to complete pragma, module name,
|
|
arbitrary identifier, etc. Returns nil in case it is
|
|
impossible to grab prefix.
|
|
|
|
Possible prefix types are:
|
|
|
|
* haskell-completions-pragma-name-prefix
|
|
* haskell-completions-ghc-option-prefix
|
|
* haskell-completions-language-extension-prefix
|
|
* haskell-completions-module-name-prefix
|
|
* haskell-completions-identifier-prefix
|
|
* haskell-completions-general-prefix
|
|
|
|
the last type is used in cases when completing things inside comments.
|
|
|
|
If provided optional MINLEN parameter this function will return
|
|
result only if prefix length is not less than MINLEN."
|
|
(when (haskell-completions-can-grab-prefix)
|
|
(let ((prefix (cond
|
|
((haskell-completions-grab-pragma-prefix))
|
|
((haskell-completions-grab-identifier-prefix)))))
|
|
(cond ((and minlen prefix)
|
|
(when (>= (length (nth 2 prefix)) minlen)
|
|
prefix))
|
|
(prefix prefix)))))
|
|
|
|
(defun haskell-completions--simple-completions (prefix)
|
|
"Provide a list of completion candidates for given PREFIX.
|
|
This function is used internally in
|
|
`haskell-completions-completion-at-point' and
|
|
`haskell-completions-sync-repl-completion-at-point'.
|
|
|
|
It provides completions for haskell keywords, language pragmas,
|
|
GHC's options, and language extensions.
|
|
|
|
PREFIX should be a list such one returned by
|
|
`haskell-completions-grab-identifier-prefix'."
|
|
(cl-destructuring-bind (beg end _pfx typ) prefix
|
|
(when (not (eql typ 'haskell-completions-general-prefix))
|
|
(let ((candidates
|
|
(cl-case typ
|
|
('haskell-completions-pragma-name-prefix
|
|
haskell-completions--pragma-names)
|
|
('haskell-completions-ghc-option-prefix
|
|
haskell-ghc-supported-options)
|
|
('haskell-completions-language-extension-prefix
|
|
haskell-ghc-supported-extensions)
|
|
(otherwise
|
|
(append (when (bound-and-true-p haskell-tags-on-save)
|
|
tags-completion-table)
|
|
haskell-completions--keywords)))))
|
|
(list beg end candidates)))))
|
|
|
|
;;;###autoload
|
|
(defun haskell-completions-completion-at-point ()
|
|
"Provide completion list for thing at point.
|
|
This function is used in non-interactive `haskell-mode'. It
|
|
provides completions for haskell keywords, language pragmas,
|
|
GHC's options, and language extensions, but not identifiers."
|
|
(let ((prefix (haskell-completions-grab-prefix)))
|
|
(when prefix
|
|
(haskell-completions--simple-completions prefix))))
|
|
|
|
(defun haskell-completions-sync-repl-completion-at-point ()
|
|
"A completion function used in `interactive-haskell-mode'.
|
|
Completion candidates are provided quering current haskell
|
|
process, that is sending `:complete repl' command.
|
|
|
|
Completes all possible things: everything that can be completed
|
|
with non-interactive function
|
|
`haskell-completions-completion-at-point' plus identifier
|
|
completions.
|
|
|
|
Returns nil if no completions available."
|
|
(let ((prefix-data (haskell-completions-grab-prefix)))
|
|
(when prefix-data
|
|
(cl-destructuring-bind (beg end pfx typ) prefix-data
|
|
(when (and (not (eql typ 'haskell-completions-general-prefix))
|
|
(or haskell-completions-complete-operators
|
|
(not (save-excursion
|
|
(goto-char (1- end))
|
|
(haskell-mode--looking-at-varsym)))))
|
|
;; do not complete things in comments
|
|
(if (cl-member
|
|
typ
|
|
'(haskell-completions-pragma-name-prefix
|
|
haskell-completions-ghc-option-prefix
|
|
haskell-completions-language-extension-prefix))
|
|
;; provide simple completions
|
|
(haskell-completions--simple-completions prefix-data)
|
|
;; only two cases left: haskell-completions-module-name-prefix
|
|
;; and haskell-completions-identifier-prefix
|
|
(let* ((is-import (eql typ 'haskell-completions-module-name-prefix))
|
|
(candidates
|
|
(when (and (haskell-session-maybe)
|
|
(not (haskell-process-cmd
|
|
(haskell-interactive-process)))
|
|
;; few possible extra checks would be:
|
|
;; (haskell-process-get 'is-restarting)
|
|
;; (haskell-process-get 'evaluating)
|
|
)
|
|
;; if REPL is available and not busy try to query it for
|
|
;; completions list in case of module name or identifier
|
|
;; prefixes
|
|
(haskell-completions-sync-complete-repl pfx is-import))))
|
|
;; append candidates with keywords
|
|
(list beg end (append
|
|
candidates
|
|
haskell-completions--keywords)))))))))
|
|
|
|
(defun haskell-completions-sync-complete-repl (prefix &optional import)
|
|
"Return completion list for given PREFIX querying REPL synchronously.
|
|
When optional IMPORT argument is non-nil complete PREFIX
|
|
prepending \"import \" keyword (useful for module names). This
|
|
function is supposed for internal use."
|
|
(haskell-process-get-repl-completions
|
|
(haskell-interactive-process)
|
|
(if import
|
|
(concat "import " prefix)
|
|
prefix)))
|
|
|
|
(provide 'haskell-completions)
|
|
;;; haskell-completions.el ends here
|