[Fix #2040] Fix fontification of conditional expressions in cljc files

Author: vspinu

cider-mode.el

@@ -454,15 +454,13 @@ The value can also be t, which means to font-lock as much as possible."
 
 (defconst cider-reader-conditionals-regexp "\\(?:#\\?@?[[:space:]\n]*(\\)"
   "Regexp for matching reader conditionals with a non-capturing group.
-
 Starts from the reader macro characters to the opening parentheses.")
 
 (defvar cider--reader-conditionals-match-data (list nil nil)
   "Reusable list for `match-data` in reader conditionals font lock matchers.")
 
 (defun cider--search-reader-conditionals (limit)
   "Matcher for finding reader conditionals.
-
 Search is done with the given LIMIT."
   (when (and cider-font-lock-reader-conditionals
              (cider-connected-p))
@@ -481,25 +479,26 @@ Search is done with the given LIMIT."
 
 (defun cider--anchored-search-suppressed-forms-internal (limit)
   "Helper function for `cider--anchored-search-suppressed-forms`.
-
 LIMIT is the same as the LIMIT in `cider--anchored-search-suppressed-forms`"
-  (let ((expr (read (current-buffer)))
-        (start (save-excursion (backward-sexp) (point))))
-    (when (<= (point) limit)
-      (forward-sexp)
-      (if (not (string-equal (symbol-name expr) (concat ":" (cider-connection-type-for-buffer))))
-          (ignore-errors
-            (cl-assert (<= (point) limit))
-            (let ((md (match-data nil cider--reader-conditionals-match-data)))
-              (setf (nth 0 md) start)
-              (setf (nth 1 md) (point))
-              (set-match-data md)
-              t))
-        (cider--anchored-search-suppressed-forms-internal limit)))))
+  (let ((types (cider-project-connections-types)))
+    (when (= (length types) 1)
+      (let ((type (car types))
+            (expr (read (current-buffer)))
+            (start (save-excursion (backward-sexp) (point))))
+        (when (<= (point) limit)
+          (forward-sexp)
+          (if (not (string-equal (symbol-name expr) (concat ":" type)))
+              (ignore-errors
+                (cl-assert (<= (point) limit))
+                (let ((md (match-data nil cider--reader-conditionals-match-data)))
+                  (setf (nth 0 md) start)
+                  (setf (nth 1 md) (point))
+                  (set-match-data md)
+                  t))
+            (cider--anchored-search-suppressed-forms-internal limit)))))))
 
 (defun cider--anchored-search-suppressed-forms (limit)
   "Matcher for finding unused reader conditional expressions.
-
 An unused reader conditional expression is an expression for a platform
 that does not match the CIDER connection for the buffer.  Search is done
 with the given LIMIT."

test/cider-font-lock-tests.el

@@ -66,16 +66,16 @@
   (describe "when cider is connected"
     (it "uses cider-reader-conditional-face"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
         (let ((cider-font-lock-reader-conditionals t)
               (found (cider--face-exists-in-range-p (point-min) (point-max)
-                                             'cider-reader-conditional-face)))
+                                                    'cider-reader-conditional-face)))
           (expect found :to-be-truthy))))
 
     (it "highlights unmatched reader conditionals"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-exists-in-range-p 4 12 'cider-reader-conditional-face)
@@ -87,7 +87,7 @@
 
     (it "works with splicing"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer "[1 2 #?(:clj [3 4] :cljs [5 6] :cljr [7 8])]"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-exists-in-range-p 1 18 'cider-reader-conditional-face)
@@ -99,38 +99,38 @@
 
     (it "does not apply inside strings or comments"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer "\"#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\" ;; #?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-exists-in-range-p (point-min) (point-max) 'cider-reader-conditional-face)
                   :not :to-be-truthy))))
 
     (it "does not apply inside strings or comments"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer "\"#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\" ;; #?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-exists-in-range-p (point-min) (point-max) 'cider-reader-conditional-face)
                   :not :to-be-truthy))))
 
     (it "highlights all unmatched reader conditionals"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("cljs"))
       (cider--test-with-temp-buffer
           "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\n#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\n"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-covers-range-p 14 24 'cider-reader-conditional-face)
-                  :to-be-truthy)
+                  :not :to-be-truthy)
           (expect (cider--face-covers-range-p 26 36 'cider-reader-conditional-face)
                   :to-be-truthy)
           (expect (cider--face-covers-range-p 52 62 'cider-reader-conditional-face)
-                  :to-be-truthy)
+                  :not :to-be-truthy)
           (expect (cider--face-covers-range-p 64 74 'cider-reader-conditional-face)
                   :to-be-truthy))))
 
     (it "does not highlight beyond the limits of the reader conditional group"
       (spy-on 'cider-connected-p :and-return-value t)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
+      (spy-on 'cider-project-connections-types :and-return-value '("clj"))
       (cider--test-with-temp-buffer
           "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\n#?(:clj 'clj :cljs 'cljs :cljr 'cljr)\n"
         (let ((cider-font-lock-reader-conditionals t))
@@ -141,10 +141,18 @@
           (expect (cider--face-exists-in-range-p 75 (point-max) 'cider-reader-conditional-face)
                   :not :to-be-truthy)))))
 
+  (describe "when multiple connections are connected"
+    (it "is disabled"
+      (spy-on 'cider-connected-p :and-return-value nil)
+      (spy-on 'cider-project-connections-types :and-return-value '("clj" "cljs"))
+      (cider--test-with-temp-buffer "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
+        (let ((cider-font-lock-reader-conditionals t))
+          (expect (cider--face-exists-in-range-p (point-min) (point-max) 'cider-reader-conditional-face)
+                  :not :to-be-truthy)))))
+  
   (describe "when cider is not connected"
     (it "is disabled"
       (spy-on 'cider-connected-p :and-return-value nil)
-      (spy-on 'cider-connection-type-for-buffer :and-return-value "clj")
       (cider--test-with-temp-buffer "#?(:clj 'clj :cljs 'cljs :cljr 'cljr)"
         (let ((cider-font-lock-reader-conditionals t))
           (expect (cider--face-exists-in-range-p (point-min) (point-max) 'cider-reader-conditional-face)