ghc-mod/elisp/ghc-check.el

337 lines
11 KiB
EmacsLisp
Raw Normal View History

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; ghc-check.el
;;;
;; Author: Kazu Yamamoto <Kazu@Mew.org>
;; Created: Mar 9, 2014
;;; Code:
(require 'ghc-func)
2014-03-25 05:29:18 +00:00
(require 'ghc-process)
2014-03-20 08:55:20 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; stolen from flymake.el
(defface ghc-face-error
'((((supports :underline (:style wave)))
2014-03-31 01:37:05 +00:00
:underline (:style wave :color "orangered"))
2014-03-20 08:55:20 +00:00
(t
:inherit error))
"Face used for marking error lines."
:group 'ghc)
(defface ghc-face-warn
'((((supports :underline (:style wave)))
2014-03-31 01:37:05 +00:00
:underline (:style wave :color "gold"))
2014-03-20 08:55:20 +00:00
(t
:inherit warning))
"Face used for marking warning lines."
:group 'ghc)
2014-03-25 13:30:19 +00:00
(defvar ghc-check-error-fringe (propertize "!" 'display '(left-fringe exclamation-mark)))
(defvar ghc-check-warning-fringe (propertize "?" 'display '(left-fringe question-mark)))
2014-04-07 05:51:24 +00:00
(defvar ghc-display-error nil
"*An action to display errors/warnings for 'M-n' and 'M-p:
nil does not display errors/warnings.
'minibuffer displays errors/warnings in the minibuffer.
'other-buffer displays errors/warnings in the other buffer.
")
2014-04-05 13:39:22 +00:00
2014-03-20 08:55:20 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun ghc-check-syntax ()
2014-03-25 05:29:18 +00:00
(interactive)
(setq mode-line-process " -:-") ;; fixme
(ghc-with-process (ghc-check-send) 'ghc-check-callback))
2014-03-20 08:55:20 +00:00
2014-03-25 05:29:18 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(ghc-defstruct hilit-info file line msg err)
2014-03-25 05:29:18 +00:00
(defun ghc-check-send ()
(let ((file (buffer-file-name)))
(if ghc-check-command
(let ((opts (ghc-haskell-list-of-string ghc-hlint-options)))
(if opts
(format "lint %s %s\n" opts file)
(format "lint %s\n" file)))
(format "check %s\n" file))))
2014-03-25 05:29:18 +00:00
2014-03-28 05:41:12 +00:00
(defun ghc-haskell-list-of-string (los)
(when los
(concat "["
(mapconcat (lambda (x) (concat "\"" x "\"")) los ", ")
"]")))
2014-03-25 05:29:18 +00:00
(defun ghc-check-callback ()
2014-04-19 07:14:02 +00:00
(let* ((errs (ghc-read-lisp-this-buffer))
(infos (ghc-to-info errs)))
2014-03-25 05:29:18 +00:00
(cond
(infos
(let ((file ghc-process-original-file)
(buf ghc-process-original-buffer))
(ghc-check-highlight-original-buffer file buf infos)))
(t
(with-current-buffer ghc-process-original-buffer
(remove-overlays (point-min) (point-max) 'ghc-check t))))
(with-current-buffer ghc-process-original-buffer
(let ((len (length infos)))
(if (= len 0)
(setq mode-line-process "")
(let* ((errs (ghc-filter 'ghc-hilit-info-get-err infos))
(elen (length errs))
(wlen (- len elen)))
(setq mode-line-process (format " %d:%d" elen wlen))))))))
2014-03-20 08:55:20 +00:00
2014-04-19 07:14:02 +00:00
(defun ghc-to-info (errs)
;; [^\t] to include \n.
(let ((regex "^\\([^\n]*\\):\\([0-9]+\\):\\([0-9]+\\): *\\([^\t]+\\)")
info infos)
(dolist (err errs (nreverse infos))
(when (string-match regex err)
(let* ((file (expand-file-name (match-string 1 err))) ;; for Windows
(line (string-to-number (match-string 2 err)))
;; don't take column to make multiple same errors to a single.
(msg (match-string 4 err))
(wrn (string-match "^Warning" msg))
(info (ghc-make-hilit-info
:file file
:line line
:msg msg
:err (not wrn))))
(unless (member info infos)
(ghc-add infos info)))))))
2014-03-20 08:39:56 +00:00
(defun ghc-check-highlight-original-buffer (ofile buf infos)
(with-current-buffer buf
(remove-overlays (point-min) (point-max) 'ghc-check t)
(save-excursion
(goto-char (point-min))
(dolist (info infos)
(let ((line (ghc-hilit-info-get-line info))
(msg (ghc-hilit-info-get-msg info))
2014-03-20 08:39:56 +00:00
(file (ghc-hilit-info-get-file info))
(err (ghc-hilit-info-get-err info))
beg end ovl)
2014-03-20 06:32:54 +00:00
;; FIXME: This is the Shlemiel painter's algorithm.
;; If this is a bottleneck for a large code, let's fix.
2014-03-19 13:57:05 +00:00
(goto-char (point-min))
2014-03-20 08:39:56 +00:00
(cond
((string= ofile file)
(forward-line (1- line))
(while (eq (char-after) 32) (forward-char))
(setq beg (point))
(forward-line)
(setq end (1- (point))))
(t
(setq beg (point))
(forward-line)
(setq end (point))))
(setq ovl (make-overlay beg end))
(overlay-put ovl 'ghc-check t)
2014-03-20 08:39:56 +00:00
(overlay-put ovl 'ghc-file file)
2014-03-25 13:30:19 +00:00
(overlay-put ovl 'ghc-msg msg)
2014-04-19 07:14:02 +00:00
(overlay-put ovl 'help-echo msg)
2014-03-25 13:30:19 +00:00
(let ((fringe (if err ghc-check-error-fringe ghc-check-warning-fringe))
(face (if err 'ghc-face-error 'ghc-face-warn)))
(overlay-put ovl 'before-string fringe)
(overlay-put ovl 'face face)))))))
2014-03-19 13:57:05 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2014-04-08 04:35:16 +00:00
(defun ghc-overlay-p (ovl)
(overlay-get ovl 'ghc-check))
(defun ghc-check-overlay-at (p)
(ghc-filter 'ghc-overlay-p (overlays-at p)))
(ghc-defstruct file-msgs file msgs)
(defun ghc-get-errors-over-warnings ()
(let ((ovls (ghc-check-overlay-at (point))))
(when ovls
(let ((msgs (mapcar (lambda (ovl) (overlay-get ovl 'ghc-msg)) ovls))
2014-04-08 04:42:41 +00:00
(file (overlay-get (car ovls) 'ghc-file))
errs wrns)
(dolist (msg msgs)
(if (string-match "^Warning" msg)
2014-04-19 11:09:47 +00:00
(ghc-add wrns msg)
(ghc-add errs msg)))
2014-04-08 04:42:41 +00:00
(ghc-make-file-msgs :file file :msgs (nconc errs wrns))))))
2014-04-08 04:35:16 +00:00
2014-03-20 06:32:54 +00:00
(defun ghc-display-errors ()
2014-03-19 13:57:05 +00:00
(interactive)
2014-04-08 04:35:16 +00:00
(let ((file-msgs (ghc-get-errors-over-warnings)))
(if (null file-msgs)
2014-03-19 13:57:05 +00:00
(message "No errors or warnings")
2014-04-08 04:35:16 +00:00
(let ((file (ghc-file-msgs-get-file file-msgs))
(msgs (ghc-file-msgs-get-msgs file-msgs)))
(ghc-display
nil
(lambda ()
(insert file "\n\n")
(mapc (lambda (x) (insert x "\n\n")) msgs)))))))
2014-03-19 13:57:05 +00:00
(defun ghc-display-errors-to-minibuf ()
2014-04-08 04:35:16 +00:00
(let ((file-msgs (ghc-get-errors-over-warnings)))
(if (null file-msgs)
(message "No errors or warnings")
2014-04-08 04:35:16 +00:00
(let* ((file (ghc-file-msgs-get-file file-msgs))
(msgs (ghc-file-msgs-get-msgs file-msgs))
2014-04-19 07:14:02 +00:00
(errmsg (mapconcat 'identity msgs "\n"))
2014-04-08 04:35:16 +00:00
(buffile buffer-file-name))
(if (string-equal buffile file)
2014-04-07 06:23:18 +00:00
(message "%s" errmsg)
2014-04-08 04:35:16 +00:00
(message "%s\n\n%s" file errmsg))))))
2014-03-20 08:55:20 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2014-03-20 06:32:54 +00:00
(defun ghc-goto-prev-error ()
(interactive)
(let* ((here (point))
(ovls0 (ghc-check-overlay-at here))
(end (if ovls0 (overlay-start (car ovls0)) here))
(ovls1 (overlays-in (point-min) end))
(ovls2 (ghc-filter (lambda (ovl) (overlay-get ovl 'ghc-check)) ovls1))
(pnts (mapcar 'overlay-start ovls2)))
(if pnts (goto-char (apply 'max pnts))))
(cond
((eq ghc-display-error 'minibuffer) (ghc-display-errors-to-minibuf))
((eq ghc-display-error 'other-buffer) (ghc-display-errors))))
2014-03-20 06:32:54 +00:00
(defun ghc-goto-next-error ()
(interactive)
(let* ((here (point))
(ovls0 (ghc-check-overlay-at here))
(beg (if ovls0 (overlay-end (car ovls0)) here))
(ovls1 (overlays-in beg (point-max)))
(ovls2 (ghc-filter (lambda (ovl) (overlay-get ovl 'ghc-check)) ovls1))
(pnts (mapcar 'overlay-start ovls2)))
(if pnts (goto-char (apply 'min pnts))))
(cond
((eq ghc-display-error 'minibuffer) (ghc-display-errors-to-minibuf))
((eq ghc-display-error 'other-buffer) (ghc-display-errors))))
2014-03-20 08:55:20 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2014-03-20 09:06:04 +00:00
(defun ghc-check-insert-from-warning ()
(interactive)
(dolist (data (mapcar (lambda (ovl) (overlay-get ovl 'ghc-msg)) (ghc-check-overlay-at (point))))
(save-excursion
(cond
((string-match "Inferred type: \\|no type signature:" data)
(beginning-of-line)
(insert-before-markers (ghc-extract-type data) "\n"))
((string-match "lacks an accompanying binding" data)
(beginning-of-line)
(when (looking-at "^\\([^ ]+\\) *::")
(save-match-data
(forward-line)
(if (not (bolp)) (insert "\n")))
(insert (match-string 1) " = undefined\n")))
2014-03-25 05:58:20 +00:00
;; GHC 7.8 uses Unicode for single-quotes.
2014-04-19 07:14:02 +00:00
((string-match "Not in scope: type constructor or class .\\([^\n]+\\)." data)
2014-03-25 13:05:33 +00:00
(let ((sym (match-string 1 data)))
(ghc-ins-mod sym)))
2014-04-19 07:14:02 +00:00
((string-match "Not in scope: .\\([^\n]+\\)." data)
2014-03-25 05:58:20 +00:00
(let ((sym (match-string 1 data)))
2014-03-26 02:32:08 +00:00
(if (or (string-match "\\." sym) ;; qualified
(y-or-n-p (format "Import module for %s?" sym)))
2014-03-25 05:58:20 +00:00
(ghc-ins-mod sym)
(unless (re-search-forward "^$" nil t)
(goto-char (point-max))
(insert "\n"))
(insert "\n" (ghc-enclose sym) " = undefined\n"))))
2014-03-20 09:06:04 +00:00
((string-match "Pattern match(es) are non-exhaustive" data)
(let* ((fn (ghc-get-function-name))
(arity (ghc-get-function-arity fn)))
(ghc-insert-underscore fn arity)))
2014-04-19 07:14:02 +00:00
;; fixme
((string-match "Found:\n[ ]*\\([^\n]+\\)\nWhy not:\n[ ]*\\([^\n]+\\)" data)
2014-03-20 09:06:04 +00:00
(let ((old (match-string 1 data))
(new (match-string 2 data)))
(beginning-of-line)
(when (search-forward old nil t)
(let ((end (point)))
(search-backward old nil t)
(delete-region (point) end))
2014-03-25 05:58:20 +00:00
(insert new))))
(t
2014-03-25 13:05:33 +00:00
(message "Nothing was done"))))))
2014-03-20 09:06:04 +00:00
(defun ghc-extract-type (str)
(with-temp-buffer
(insert str)
(goto-char (point-min))
2014-04-19 07:14:02 +00:00
(when (re-search-forward "Inferred type: \\|no type signature:\\( \\|\n +\\)?" nil t)
2014-03-20 09:06:04 +00:00
(delete-region (point-min) (point)))
(when (re-search-forward " forall [^.]+\\." nil t)
(replace-match ""))
2014-04-19 07:14:02 +00:00
(while (re-search-forward "\n +" nil t)
2014-03-20 09:06:04 +00:00
(replace-match " "))
(goto-char (point-min))
(while (re-search-forward "\\[Char\\]" nil t)
(replace-match "String"))
2014-03-27 05:23:32 +00:00
(buffer-substring-no-properties (point-min) (point-max))))
2014-03-20 09:06:04 +00:00
(defun ghc-get-function-name ()
(save-excursion
(beginning-of-line)
(when (looking-at "\\([^ ]+\\) ")
(match-string 1))))
(defun ghc-get-function-arity (fn)
(when fn
(save-excursion
(let ((regex (format "^%s *::" (regexp-quote fn))))
(when (re-search-backward regex nil t)
(ghc-get-function-arity0))))))
(defun ghc-get-function-arity0 ()
(let ((end (save-excursion (end-of-line) (point)))
(arity 0))
(while (search-forward "->" end t)
(setq arity (1+ arity)))
arity))
(defun ghc-insert-underscore (fn ar)
(when fn
(let ((arity (or ar 1)))
(save-excursion
(goto-char (point-max))
(re-search-backward (format "^%s *::" (regexp-quote fn)))
(forward-line)
(re-search-forward "^$" nil t)
(insert fn)
(dotimes (i arity)
(insert " _"))
(insert " = error \"" fn "\"")))))
2014-03-27 01:35:09 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2014-03-31 05:58:41 +00:00
(defun ghc-jump-file ()
(interactive)
(let* ((ovl (car (ghc-check-overlay-at 1)))
(file (if ovl (overlay-get ovl 'ghc-file))))
(if file (find-file file))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2014-03-27 01:35:09 +00:00
(defvar ghc-hlint-options nil "*Hlint options")
(defvar ghc-check-command nil)
(defun ghc-toggle-check-command ()
(interactive)
(setq ghc-check-command (not ghc-check-command))
(if ghc-check-command
(message "Syntax check with hlint")
(message "Syntax check with GHC")))
(provide 'ghc-check)