Merge pull request #321 from Malabarba/fix-sexp

[Fix clojure-emacs/cider#1323] Sexp navigation near end of buffer

Author: bbatsov

clojure-mode.el

@@ -66,6 +66,7 @@
 
 (require 'cl-lib)
 (require 'imenu)
+(require 'newcomment)
 
 (declare-function lisp-fill-paragraph  "lisp-mode" (&optional justify))
 
@@ -682,9 +683,11 @@ Implementation function for `clojure--find-indent-spec'."
       (let* ((function (thing-at-point 'symbol))
              (method (or (when function ;; Is there a spec here?
                            (clojure--get-indent-method function))
-                         (progn (up-list) ;; Otherwise look higher up.
-                                (clojure-backward-logical-sexp 1)
-                                (clojure--find-indent-spec-backtracking)))))
+                         ;; `up-list' errors on unbalanced sexps.
+                         (ignore-errors
+                           (up-list) ;; Otherwise look higher up.
+                           (clojure-backward-logical-sexp 1)
+                           (clojure--find-indent-spec-backtracking)))))
         (when (numberp method)
           (setq method (list method)))
         (pcase method
@@ -733,6 +736,18 @@ LAST-SEXP is the start of the previous sexp."
     (skip-chars-forward "[:blank:]")
     (current-column)))
 
+(defun clojure--not-function-form-p ()
+  "Non-nil if form at point doesn't represent a function call."
+  (or (member (char-after) '(?\[ ?\{))
+      (save-excursion ;; Catch #?@ (:cljs ...)
+        (skip-chars-backward "\r\n[:blank:]")
+        (when (eq (char-before) ?@)
+          (forward-char -1))
+        (and (eq (char-before) ?\?)
+             (eq (char-before (1- (point))) ?\#)))
+      ;; Car of form is not a symbol.
+      (not (looking-at ".\\(?:\\sw\\|\\s_\\)"))))
+
 (defun clojure-indent-function (indent-point state)
   "When indenting a line within a function call, indent properly.
 
@@ -760,12 +775,7 @@ This function also returns nil meaning don't specify the indentation."
     ;; Goto to the open-paren.
     (goto-char (elt state 1))
     ;; Maps, sets, vectors and reader conditionals.
-    (if (or (member (char-after) '(?\[ ?\{))
-            (and (eq (char-before) ?\?)
-                 (eq (char-before (1- (point))) ?\#))
-            ;; Car of form is not a symbol.
-            (and (elt state 2)
-                 (not (looking-at ".\\sw\\|.\\s_"))))
+    (if (clojure--not-function-form-p)
         (1+ (current-column))
       ;; Function or macro call.
       (forward-char 1)
@@ -1103,23 +1113,23 @@ Returns a list pair, e.g. (\"defn\" \"abc\") or (\"deftest\" \"some-test\")."
 
 
 ;;; Sexp navigation
-(defun clojure--looking-at-logical-sexp ()
+(defun clojure--looking-at-non-logical-sexp ()
   "Return non-nil if sexp after point represents code.
 Sexps that don't represent code are ^metadata or #reader.macros."
-  (forward-sexp 1)
-  (forward-sexp -1)
-  (not (looking-at-p "\\^\\|#[?[:alpha:]]")))
+  (comment-normalize-vars)
+  (comment-forward (point-max))
+  (looking-at-p "\\^\\|#[?[:alpha:]]"))
 
 (defun clojure-forward-logical-sexp (&optional n)
   "Move forward N logical sexps.
 This will skip over sexps that don't represent objects, so that ^hints and
 #reader.macros are considered part of the following sexp."
   (interactive "p")
-  (let ((forward-sexp-function nil))
-    (if (< n 0)
-        (clojure-backward-logical-sexp (- n))
+  (if (< n 0)
+      (clojure-backward-logical-sexp (- n))
+    (let ((forward-sexp-function nil))
       (while (> n 0)
-        (while (not (clojure--looking-at-logical-sexp))
+        (while (clojure--looking-at-non-logical-sexp)
           (forward-sexp 1))
         ;; The actual sexp
         (forward-sexp 1)
@@ -1132,17 +1142,18 @@ This will skip over sexps that don't represent objects, so that ^hints and
   (interactive "p")
   (if (< n 0)
       (clojure-forward-logical-sexp (- n))
-    (while (> n 0)
-      ;; The actual sexp
-      (backward-sexp 1)
-      ;; Non-logical sexps.
-      (while (and (not (bobp))
-                  (ignore-errors
-                    (save-excursion
-                      (backward-sexp 1)
-                      (not (clojure--looking-at-logical-sexp)))))
-        (backward-sexp 1))
-      (setq n (1- n)))))
+    (let ((forward-sexp-function nil))
+      (while (> n 0)
+        ;; The actual sexp
+        (backward-sexp 1)
+        ;; Non-logical sexps.
+        (while (and (not (bobp))
+                    (ignore-errors
+                      (save-excursion
+                        (backward-sexp 1)
+                        (clojure--looking-at-non-logical-sexp))))
+          (backward-sexp 1))
+        (setq n (1- n))))))
 
 (defconst clojurescript-font-lock-keywords
   (eval-when-compile

test/clojure-mode-indentation-test.el

@@ -262,6 +262,45 @@ values of customisable variables."
   (x [_]
     1))")
 
+(def-full-indent-test reader-conditionals
+  "#?@ (:clj []
+     :cljs [])")
+
+
+;;; Misc
+
+(defun non-func (form-a form-b)
+  (with-temp-buffer
+    (clojure-mode)
+    (insert form-a)
+    (save-excursion (insert form-b))
+    (clojure--not-function-form-p)))
+
+(ert-deftest non-function-form ()
+  (dolist (form '(("#?@ " "(c d)")
+                  ("#?@" "(c d)")
+                  ("#? " "(c d)")
+                  ("#?" "(c d)")
+                  ("" "[asda]")
+                  ("" "{a b}")
+                  ("#" "{a b}")
+                  ("" "(~)")))
+    (should (apply #'non-func form)))
+  (dolist (form '("(c d)"
+                  "(.c d)"
+                  "(:c d)"
+                  "(c/a d)"
+                  "(.c/a d)"
+                  "(:c/a d)"
+                  "(c/a)"
+                  "(:c/a)"
+                  "(.c/a)"))
+    (should-not (non-func "" form))
+    (should-not (non-func "^hint" form))
+    (should-not (non-func "#macro" form))
+    (should-not (non-func "^hint " form))
+    (should-not (non-func "#macro " form))))
+
 (provide 'clojure-mode-indentation-test)
 
 ;; Local Variables:

test/clojure-mode-sexp-test.el

@@ -40,6 +40,31 @@
     (clojure-backward-logical-sexp 1)
     (should (looking-at-p "\\^String biverse"))))
 
+(ert-deftest test-buffer-corners ()
+  (with-temp-buffer
+    (insert "^String reverse")
+    (clojure-mode)
+    ;; Return nil and don't error
+    (should-not (clojure-backward-logical-sexp 100))
+    (should (looking-at-p "\\^String reverse"))
+    (should-not (clojure-forward-logical-sexp 100))
+    (should (looking-at-p "$")))
+  (with-temp-buffer
+    (clojure-mode)
+    (insert "(+ 10")
+    (should-error (clojure-backward-logical-sexp 100))
+    (goto-char (point-min))
+    (should-error (clojure-forward-logical-sexp 100))
+    ;; Just don't hang.
+    (goto-char (point-max))
+    (should-not (clojure-forward-logical-sexp 1))
+    (erase-buffer)
+    (insert "(+ 10")
+    (newline)
+    (erase-buffer)
+    (insert "(+ 10")
+    (newline-and-indent)))
+
 (provide 'clojure-mode-sexp-test)
 
 ;;; clojure-mode-sexp-test.el ends here