[nongnu] elpa/haskell-tng-mode 1009082 140/385: append indentation test

[ELPA Syncer]

branch: elpa/haskell-tng-mode
commit 10090824cd2998ad90625a4983e741cdb900b198
Author: Tseen She <ts33n.sh3@gmail.com>
Commit: Tseen She <ts33n.sh3@gmail.com>

    append indentation test
---
 haskell-tng-layout.el                 |  14 ++++
 haskell-tng-mode.el                   |   9 ++-
 haskell-tng-smie.el                   |   2 +-
 test/haskell-tng-indent-test.el       | 127 +++++++++++++++++++++++-----------
 test/src/indentation.hs.append.indent | 102 +++++++++++++++++++++++++++
 5 files changed, 210 insertions(+), 44 deletions(-)

diff --git a/haskell-tng-layout.el b/haskell-tng-layout.el
index 0a4f311..f4af977 100644
--- a/haskell-tng-layout.el
+++ b/haskell-tng-layout.el
@@ -32,8 +32,14 @@
 ;;
 ;; Anything more complicated that small brain needs improved testing.
 
+(require 'dash)
+
 (require 'haskell-tng-util)
 
+;; FIXME only search up to one line for the WLDO opener, otherwise close it out
+;; with {} This is not valid compiling Haskell code, but it allows SMIE to 
close
+;; off the s-expression.
+
 ;; Easiest cache... full buffer parse with full invalidation on any insertion.
 (defvar-local haskell-tng-layout:cache nil)
 
@@ -74,6 +80,14 @@ Designed to be called repeatedly, managing its own caching."
                   (push ";" breaks))))))
         (append (reverse closes) (reverse breaks))))))
 
+(defun haskell-tng-layout:has-virtual-at-point ()
+  "t if there is a virtual at POINT"
+  ;; avoids a measured performance hit (append indentation)
+  (unless haskell-tng-layout:cache
+    (haskell-tng-layout:rebuild-cache-full))
+  (--any (member (point) it)
+         haskell-tng-layout:cache))
+
 (defun haskell-tng-layout:rebuild-cache-full ()
   (let (case-fold-search
         cache)
diff --git a/haskell-tng-mode.el b/haskell-tng-mode.el
index fbc9e4f..86594bc 100644
--- a/haskell-tng-mode.el
+++ b/haskell-tng-mode.el
@@ -73,10 +73,13 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
    font-lock-multiline t
    font-lock-extend-region-functions haskell-tng:extend-region-functions
 
-   ;; whitespace is meaningful, no electric indentation
-   electric-indent-inhibit t
-
    prettify-symbols-alist haskell-tng-mode:prettify-symbols)
+
+  ;; whitespace is meaningful, disable electric indentation. Note that
+  ;; `electric-indent-inhibit' causes a performance regression in SMIE
+  ;; indentation, so it's best to just make sure it is disabled.
+  (electric-indent-mode 0)
+
   (setq-local projectile-tags-command "fast-tags -Re --exclude=dist-newstyle 
.")
   (setq-local smie-blink-matching-inners nil) ;; c.f. `smie-closer-alist'
 
diff --git a/haskell-tng-smie.el b/haskell-tng-smie.el
index 8caab9f..db485c9 100644
--- a/haskell-tng-smie.el
+++ b/haskell-tng-smie.el
@@ -242,7 +242,7 @@ current line."
       (forward-line))
     (goto-char start)
     (while (< (point) bound)
-      (when (haskell-tng-layout:virtuals-at-point)
+      (when (haskell-tng-layout:has-virtual-at-point)
         (push (current-column) relevant))
       (forward-char))
     relevant))
diff --git a/test/haskell-tng-indent-test.el b/test/haskell-tng-indent-test.el
index 07c3128..213de04 100644
--- a/test/haskell-tng-indent-test.el
+++ b/test/haskell-tng-indent-test.el
@@ -12,31 +12,48 @@
 (require 'haskell-tng-testutils
          "test/haskell-tng-testutils.el")
 
-  ;; Three indentation regression tests are possible:
-  ;;
-  ;;   1. newline-and-indent with the rest of the file deleted (append)
-  ;;   2. newline-and-indent with the rest of the file intact (insert)
-  ;;   3. indent-line-function at the beginning of each line (re-indent)
-  ;;
-  ;; each maybe with alternative indentation suggestions.
-  ;;
-  ;; Expectations could use lines of symbols such as | and . or digits to
-  ;; indicate where the indentation(s) go.
-  ;;
-  ;; Test 1 involves a lot of buffer refreshing and will be very slow.
-
-(ert-deftest haskell-tng-newline-indent-file-tests ()
-  (should (have-expected-newline-indent-insert (testdata 
"src/indentation.hs")))
-
-  ;; (should (have-expected-newline-indent-insert (testdata "src/layout.hs")))
-  ;; (should (have-expected-newline-indent-insert (testdata "src/medley.hs")))
+;; Three indentation regression tests are possible:
+;;
+;;   1. newline-and-indent with the rest of the file deleted (append)
+;;   2. newline-and-indent with the rest of the file intact (insert)
+;;   3. indent-line-function at the beginning of each line (re-indent)
+;;
+;; each maybe with alternative indentation suggestions.
+;;
+;; Expectations could use lines of symbols such as | and . or digits to
+;; indicate where the indentation(s) go.
+;;
+;; Test 1 involves a lot of buffer refreshing and will be very slow.
+
+(ert-deftest haskell-tng-append-indent-file-tests ()
+  ;; this is a very slow test
+
+  ;; (require 'profiler)
+  ;; (profiler-start 'cpu)
+
+  (should (have-expected-append-indent (testdata "src/indentation.hs")))
+
+  ;; (profiler-report)
+  ;; (profiler-report-write-profile "indentation.profile")
+  ;; (profiler-stop)
+
+  ;; To interactively inspect
+  ;; (profiler-find-profile "../indentation.profile")
+  )
+
+
+(ert-deftest haskell-tng-indent-file-tests ()
+  (should (have-expected-insert-indent (testdata "src/indentation.hs")))
+
+  ;; (should (have-expected-insert-indent (testdata "src/layout.hs")))
+  ;; (should (have-expected-insert-indent (testdata "src/medley.hs")))
   )
 
 (ert-deftest haskell-tng-reindent-file-tests ()
-  (should (have-expected-reindent-insert (testdata "src/indentation.hs")))
+  (should (have-expected-reindent (testdata "src/indentation.hs")))
 
-  ;; (should (have-expected-reindent-insert (testdata "src/layout.hs")))
-  ;; (should (have-expected-reindent-insert (testdata "src/medley.hs")))
+  ;; (should (have-expected-reindent (testdata "src/layout.hs")))
+  ;; (should (have-expected-reindent (testdata "src/medley.hs")))
   )
 
 (defun current-line-string ()
@@ -44,13 +61,22 @@
    (line-beginning-position)
    (- (line-beginning-position 2) 1)))
 
-(defun haskell-tng-indent-test:indent-insert (return-mode)
-  ;; FIXME the slow append test
-  (let (indents)
+(defun haskell-tng-indent-test:work (mode)
+  "MODE can be 'insert, 'reindent, or 'append.
+
+'append is VERY slow."
+  ;; each line could be done in parallel, if emacs allowed such a thing...
+  (let (indents kill)
     (while (not (eobp))
       ;; the command loop is necessary for this/last-command
       (cl-flet ((RET ()
                      (end-of-line)
+                     (pcase mode
+                       ('append
+                        (setq kill ;; kill-region/yank is noisy
+                              (buffer-substring-no-properties
+                               (point) (point-max)))
+                        (delete-region (point) (point-max))))
                      (ert-simulate-command '(newline-and-indent))
                      (current-column))
                 (TAB ()
@@ -59,28 +85,40 @@
 
         (let ((orig (current-indentation))
               (line (current-line-string))
-              (prime (if return-mode (RET) (TAB)))
+              (prime (pcase mode
+                       ((or 'insert 'append) (RET))
+                       ('reindent (TAB))))
               alts)
           (while (and (TAB)
                       (not (eq (current-column) prime))
                       (not (member (current-column) alts)))
             (push (current-column) alts))
-          (push `(, return-mode ,line . (,prime . ,(reverse alts))) indents)
+          (push `(,(pcase mode ((or 'insert 'append) t))
+                  ,line . (,prime . ,(reverse alts)))
+                indents)
           ;; unfortunately killing resets this-command so we can't test double
           ;; newline insertions, which could accidentally trigger alts only.
-          (if return-mode
-              (kill-whole-line)
-            (indent-line-to orig)
-            (ert-simulate-command '(forward-line))))))
+          (pcase mode
+            ('insert (kill-whole-line))
+            ('reindent
+             (indent-line-to orig)
+             (ert-simulate-command '(forward-line)))
+            ('append
+             (forward-line -1)
+             (end-of-line)
+             (save-excursion
+               (insert kill)
+               (delete-region (point) (point-max)))
+             (ert-simulate-command '(forward-line)))))))
     (reverse indents)))
 
 (defun haskell-tng-indent-test:indents-to-string (indents)
   "INDENTS is a list of INDENT.
 
-INDENT is a non-empty list of (RETURN-MODE . (LINE . (INDENT .
-ALTS))) where RETURN-MODE is t for newline insertions (i.e. LINE
-is a string of the previous line) and nil for reindent (i.e. LINE
-is a string of the current line).
+INDENT is a non-empty list of (RET . (LINE . (INDENT . ALTS)))
+where RET is t for newline insertions (i.e. LINE is a string of
+the previous line) and nil for reindent (i.e. LINE is a string of
+the current line).
 
 INDENT is the integer suggested next line indentation column and
 ALTS is a list of integer alternative indentations."
@@ -88,7 +126,7 @@ ALTS is a list of integer alternative indentations."
                 (-map #'haskell-tng-indent-test:indent-to-string indents))))
 
 (defun haskell-tng-indent-test:indent-to-string (indent)
-  (let* ((return-mode (car indent))
+  (let* ((ret (car indent))
          (line (cadr indent))
          (prime (caddr indent))
          (alts (cdddr indent))
@@ -106,26 +144,35 @@ ALTS is a list of integer alternative indentations."
         (t " "))
        repr))
     (let ((indents (s-join "" (reverse repr))))
-      (if return-mode
+      (if ret
           (list line indents)
         (list indents line)))))
 
-(defun have-expected-newline-indent-insert (file)
+(defun have-expected-insert-indent (file)
   (haskell-tng-testutils:assert-file-contents
    file
    #'haskell-tng-mode
    (lambda ()
      (haskell-tng-indent-test:indents-to-string
-      (haskell-tng-indent-test:indent-insert t)))
+      (haskell-tng-indent-test:work 'insert)))
    "insert.indent"))
 
-(defun have-expected-reindent-insert (file)
+(defun have-expected-reindent (file)
   (haskell-tng-testutils:assert-file-contents
    file
    #'haskell-tng-mode
    (lambda ()
      (haskell-tng-indent-test:indents-to-string
-      (haskell-tng-indent-test:indent-insert nil)))
+      (haskell-tng-indent-test:work 'reindent)))
    "reindent"))
 
+(defun have-expected-append-indent (file)
+  (haskell-tng-testutils:assert-file-contents
+   file
+   #'haskell-tng-mode
+   (lambda ()
+     (haskell-tng-indent-test:indents-to-string
+      (haskell-tng-indent-test:work 'append)))
+   "append.indent"))
+
 ;;; haskell-tng-indent-test.el ends here
diff --git a/test/src/indentation.hs.append.indent 
b/test/src/indentation.hs.append.indent
new file mode 100644
index 0000000..b630885
--- /dev/null
+++ b/test/src/indentation.hs.append.indent
@@ -0,0 +1,102 @@
+-- | Idealised indentation scenarios.
+v
+--
+v
+--   Bugs and unexpected behaviour in (re-)indentation may be documented here.
+v
+--
+v
+--   Lines marked "manual correction" indicate where we expect the user to
+v
+--   re-indent because it goes against our prediction. In some of these cases,
+v
+--   we could improve the guess with semantic information (e.g. if we know that
+v
+--   the RHS of a bind is only partially applied, then we probably mean to
+v
+--   continue that line instead of start a new one).
+v
+module Indentation where
+v
+
+v
+import Foo.Bar
+v
+import Foo.Baz hiding ( gaz,
+1                       v
+                        baz
+1                       v
+                      )
+v                     1 2
+
+v                     1 2
+basic_do = do
+v
+  foo <- blah blah blah
+v 1
+  bar <- blah blah
+v 1
+         blah -- manual correction
+v 2      1
+         blah -- manual correction
+v 2      1
+  sideeffect
+v 1      2
+  sideeffect' blah
+v 1      2
+  let baz = blah blah
+v 2   1  3
+            blah -- manual correction
+v 2   3  4  1
+      gaz = blah
+v 2   1  3  4
+      haz =
+v 2   1  3  4
+        blah
+v 2   3 14  5
+  pure faz -- manual correction
+v 1   2 34  5
+
+v 1   2 34  5
+nested_do = -- manual correction
+v
+  do foo <- blah
+v    1
+     do bar <- blah -- same level as foo
+v    2  1
+        baz -- same level as bar
+v    2  1
+
+v    1  2
+nested_where a b = foo a b
+v
+  where -- TODO 2
+v
+    foo = bar baz -- indented
+v   1
+    baz = blah blah -- same level as foo
+v   1
+      where -- manual correction
+v   1
+        gaz a = blah -- indented
+v   2   1
+        faz = blah -- same level as gaz
+v   2   1
+
+v   1   2
+-- TODO case statements
+v   1   2
+-- TODO let / in
+v   1   2
+
+v   1   2
+-- TODO coproduct definitions, the | should align with =
+v   1   2
+
+v   1   2
+-- TODO lists, records, tuples
+v   1   2
+
+v   1   2
+-- TODO long type signatures vs definitions
+v   1   2
\ No newline at end of file