forked from clojure-emacs/cider
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcider-eval.el
1588 lines (1417 loc) · 69.8 KB
/
cider-eval.el
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
;;; cider-eval.el --- Interactive evaluation (compilation) functionality -*- lexical-binding: t -*-
;; Copyright © 2012-2013 Tim King, Phil Hagelberg, Bozhidar Batsov
;; Copyright © 2013-2022 Bozhidar Batsov, Artur Malabarba and CIDER contributors
;;
;; Author: Tim King <[email protected]>
;; Phil Hagelberg <[email protected]>
;; Bozhidar Batsov <[email protected]>
;; Artur Malabarba <[email protected]>
;; Hugo Duncan <[email protected]>
;; Steve Purcell <[email protected]>
;; Arne Brasseur <[email protected]>
;; This program 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 of the License, or
;; (at your option) any later version.
;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
;; This file is not part of GNU Emacs.
;;; Commentary:
;; This file contains CIDER's interactive evaluation (compilation) functionality.
;; Although Clojure doesn't really have the concept of evaluation (only
;; compilation), we're using everywhere in the code the term evaluation for
;; brevity (and to be in line with the naming employed by other similar modes).
;;
;; This files also contains all the logic related to displaying errors and
;; evaluation warnings.
;;
;; Pretty much all of the commands here are meant to be used mostly from
;; `cider-mode', but some of them might make sense in other contexts as well.
;;; Code:
(require 'ansi-color)
(require 'cl-lib)
(require 'compile)
(require 'map)
(require 'seq)
(require 'subr-x)
(require 'clojure-mode)
(require 'cider-client)
(require 'cider-common)
(require 'cider-jar)
(require 'cider-overlays)
(require 'cider-popup)
(require 'cider-repl)
(require 'cider-stacktrace)
(require 'cider-util)
(defconst cider-read-eval-buffer "*cider-read-eval*")
(defconst cider-result-buffer "*cider-result*")
(defcustom cider-show-error-buffer t
"Control the popup behavior of cider stacktraces.
The following values are possible t or 'always, 'except-in-repl,
'only-in-repl. Any other value, including nil, will cause the stacktrace
not to be automatically shown.
Irrespective of the value of this variable, the `cider-error-buffer' is
always generated in the background. Use `cider-selector' to
navigate to this buffer."
:type '(choice (const :tag "always" t)
(const except-in-repl)
(const only-in-repl)
(const :tag "never" nil))
:group 'cider)
(defcustom cider-auto-jump-to-error t
"Control the cursor jump behavior in compilation error buffer.
When non-nil automatically jump to error location during interactive
compilation. When set to 'errors-only, don't jump to warnings.
When set to nil, don't jump at all."
:type '(choice (const :tag "always" t)
(const errors-only)
(const :tag "never" nil))
:group 'cider
:package-version '(cider . "0.7.0"))
(defcustom cider-auto-select-error-buffer t
"Controls whether to auto-select the error popup buffer."
:type 'boolean
:group 'cider)
(defcustom cider-auto-track-ns-form-changes t
"Controls whether to auto-evaluate a source buffer's ns form when changed.
When non-nil CIDER will check for ns form changes before each eval command.
When nil the users are expected to take care of the re-evaluating updated
ns forms manually themselves."
:type 'boolean
:group 'cider
:package-version '(cider . "0.15.0"))
(defcustom cider-auto-inspect-after-eval t
"Controls whether to auto-update the inspector buffer after eval.
Only applies when the *cider-inspect* buffer is currently visible."
:type 'boolean
:group 'cider
:package-version '(cider . "0.25.0"))
(defcustom cider-save-file-on-load 'prompt
"Controls whether to prompt to save the file when loading a buffer.
If nil, files are not saved.
If 'prompt, the user is prompted to save the file if it's been modified.
If t, save the file without confirmation."
:type '(choice (const prompt :tag "Prompt to save the file if it's been modified")
(const nil :tag "Don't save the file")
(const t :tag "Save the file without confirmation"))
:group 'cider
:package-version '(cider . "0.6.0"))
(defcustom cider-file-loaded-hook nil
"List of functions to call when a load file has completed."
:type 'hook
:group 'cider
:package-version '(cider . "0.1.7"))
(defconst cider-output-buffer "*cider-out*")
(defcustom cider-interactive-eval-output-destination 'repl-buffer
"The destination for stdout and stderr produced from interactive evaluation."
:type '(choice (const output-buffer)
(const repl-buffer))
:group 'cider
:package-version '(cider . "0.7.0"))
(defface cider-error-highlight-face
'((((supports :underline (:style wave)))
(:underline (:style wave :color "red") :inherit unspecified))
(t (:inherit font-lock-warning-face :underline t)))
"Face used to highlight compilation errors in Clojure buffers."
:group 'cider)
(defface cider-warning-highlight-face
'((((supports :underline (:style wave)))
(:underline (:style wave :color "yellow") :inherit unspecified))
(t (:inherit font-lock-warning-face :underline (:color "yellow"))))
"Face used to highlight compilation warnings in Clojure buffers."
:group 'cider)
(defcustom cider-comment-prefix ";; => "
"The prefix to insert before the first line of commented output."
:type 'string
:group 'cider
:package-version '(cider . "0.16.0"))
(defcustom cider-comment-continued-prefix ";; "
"The prefix to use on the second and subsequent lines of commented output."
:type 'string
:group 'cider
:package-version '(cider . "0.16.0"))
(defcustom cider-comment-postfix ""
"The postfix to be appended after the final line of commented output."
:type 'string
:group 'cider
:package-version '(cider . "0.16.0"))
(defcustom cider-eval-register ?e
"The text register assigned to the most recent evaluation result.
When non-nil, the return value of all CIDER eval commands are
automatically written into this register."
:type '(choice character
(const nil))
:group 'cider
:package-version '(cider . "1.4.0"))
;;; Utilities
(defun cider--clear-compilation-highlights ()
"Remove compilation highlights."
(remove-overlays (point-min) (point-max) 'cider-note-p t))
(defun cider-clear-compilation-highlights (&optional arg)
"Remove compilation highlights.
When invoked with a prefix ARG the command doesn't prompt for confirmation."
(interactive "P")
(when (or arg (y-or-n-p "Are you sure you want to clear the compilation highlights? "))
(cider--clear-compilation-highlights)))
(defun cider--quit-error-window ()
"Buries the `cider-error-buffer' and quits its containing window."
(when-let* ((error-win (get-buffer-window cider-error-buffer)))
(save-excursion
(quit-window nil error-win))))
;;; Sideloader
;;
;; nREPL includes sideloader middleware which provides a Java classloader that
;; is able to dynamically load classes and resources at runtime by interacting
;; with the nREPL client (as opposed to using the classpath of the JVM hosting
;; nREPL server).
;;
;; This performs a similar functionality as the load-file
;; operation, where we can load Clojure namespaces (as source files) or Java
;; classes (as bytecode) by simply requiring or importing them.
;;
;; See https://nrepl.org/nrepl/design/middleware.html#sideloading
(defcustom cider-sideloader-path nil
"List of directories and jar files to scan for sideloader resources.
When not set the cider-nrepl jar will be added automatically when upgrading
an nREPL connection."
:type 'list
:group 'cider
:package-version '(cider . "1.2.0"))
(defcustom cider-dynload-cider-nrepl-version nil
"Version of the cider-nrepl jar used for dynamically upgrading a connection.
Defaults to `cider-required-middleware-version'."
:type 'string
:group 'cider
:package-version '(cider . "1.2.0"))
(defun cider-read-bytes (path)
"Read binary data from PATH.
Return the binary data as unibyte string."
;; based on f-read-bytes
(with-temp-buffer
(set-buffer-multibyte nil)
(setq buffer-file-coding-system 'binary)
(insert-file-contents-literally path nil)
(buffer-substring-no-properties (point-min) (point-max))))
(defun cider-retrieve-resource (dirs name)
"Find a resource NAME in a list DIRS of directories or jar files.
Similar to a classpath lookup. Returns the file contents as a string."
(seq-some
(lambda (path)
(cond
((file-directory-p path)
(let ((expanded (expand-file-name name path)))
(when (file-exists-p expanded)
(cider-read-bytes expanded))))
((and (file-exists-p path) (string-suffix-p ".jar" path))
(cider-jar-retrieve-resource path name))))
dirs))
(defun cider-provide-file (file)
"Provide FILE in a format suitable for sideloading."
(let ((contents (cider-retrieve-resource cider-sideloader-path file)))
(if contents
(base64-encode-string contents 'no-line-breaks)
;; if we can't find the file we should return an empty string
(base64-encode-string ""))))
(defun cider-sideloader-lookup-handler ()
"Make a sideloader-lookup handler."
(lambda (response)
(nrepl-dbind-response response (id status type name)
(if status
(when (member "sideloader-lookup" status)
(cider-request:sideloader-provide id type name))))))
(defun cider-add-middleware-handler (continue)
"Make a add-middleware handler.
CONTINUE is an optional continuation function."
(lambda (response)
(nrepl-dbind-response response (status unresolved-middleware) ;; id middleware
(when unresolved-middleware
(seq-do
(lambda (mw)
(cider-repl-emit-interactive-stderr
(concat "WARNING: middleware " mw " was not found or failed to load.\n")))
unresolved-middleware))
(when (and status (member "done" status) continue)
(funcall continue)))))
(defun cider-request:sideloader-start (&optional connection tooling)
"Perform the nREPL \"sideloader-start\" op.
If CONNECTION is nil, use `cider-current-repl'.
If TOOLING is truthy then the operation is performed over the tooling
session, rather than the regular session."
(cider-ensure-op-supported "sideloader-start")
(cider-nrepl-send-request `("op" "sideloader-start")
(cider-sideloader-lookup-handler)
connection
tooling))
(defun cider-request:sideloader-provide (id type file &optional connection)
"Perform the nREPL \"sideloader-provide\" op for ID, TYPE and FILE.
If CONNECTION is nil, use `cider-current-repl'."
(cider-nrepl-send-request `("id" ,id
"op" "sideloader-provide"
"type" ,type
"name" ,file
"content" ,(cider-provide-file file))
(cider-sideloader-lookup-handler)
connection))
(defun cider-sideloader-start (&optional connection)
"Start nREPL's sideloader.
If CONNECTION is nil, use `cider-current-repl'."
(interactive)
(message "Starting nREPL's sideloader")
(cider-request:sideloader-start connection)
(cider-request:sideloader-start connection 'tooling))
(defvar cider-nrepl-middlewares
'("cider.nrepl/wrap-apropos"
"cider.nrepl/wrap-classpath"
"cider.nrepl/wrap-clojuredocs"
"cider.nrepl/wrap-complete"
"cider.nrepl/wrap-content-type"
"cider.nrepl/wrap-debug"
"cider.nrepl/wrap-enlighten"
"cider.nrepl/wrap-format"
"cider.nrepl/wrap-info"
"cider.nrepl/wrap-inspect"
"cider.nrepl/wrap-macroexpand"
"cider.nrepl/wrap-ns"
"cider.nrepl/wrap-out"
"cider.nrepl/wrap-slurp"
"cider.nrepl/wrap-profile"
"cider.nrepl/wrap-refresh"
"cider.nrepl/wrap-resource"
"cider.nrepl/wrap-spec"
"cider.nrepl/wrap-stacktrace"
"cider.nrepl/wrap-test"
"cider.nrepl/wrap-trace"
"cider.nrepl/wrap-tracker"
"cider.nrepl/wrap-undef"
"cider.nrepl/wrap-version"
"cider.nrepl/wrap-xref"))
(defun cider-request:add-middleware (middlewares
&optional connection tooling continue)
"Use the nREPL dynamic loader to add MIDDLEWARES to the nREPL session.
- If CONNECTION is nil, use `cider-current-repl'.
- If TOOLING it truthy, use the tooling session instead of the main session.
- CONTINUE is an optional continuation function, which will be called when the
add-middleware op has finished successfully."
(cider-nrepl-send-request `("op" "add-middleware"
"middleware" ,middlewares)
(cider-add-middleware-handler continue)
connection
tooling))
(defun cider-add-cider-nrepl-middlewares (&optional connection)
"Use dynamic loading to add the cider-nrepl middlewares to nREPL.
If CONNECTION is nil, use `cider-current-repl'."
(cider-request:add-middleware
cider-nrepl-middlewares connection nil
(lambda ()
;; When the main session is done adding middleware, then do the tooling
;; session. At this point all the namespaces have been sideloaded so this
;; is faster, we don't want these to race to sideload resources.
(cider-request:add-middleware
cider-nrepl-middlewares connection 'tooling
(lambda ()
;; Ask nREPL again what its capabilities are, so we know which new
;; operations are supported.
(nrepl--init-capabilities (or connection (cider-current-repl))))))))
(defvar cider-required-middleware-version)
(defun cider-upgrade-nrepl-connection (&optional connection)
"Sideload cider-nrepl middleware.
If CONNECTION is nil, use `cider-current-repl'."
(interactive)
(when (not cider-sideloader-path)
(setq cider-sideloader-path (list (cider-jar-find-or-fetch
"cider" "cider-nrepl"
(or cider-dynload-cider-nrepl-version
cider-required-middleware-version)))))
(cider-sideloader-start connection)
(cider-add-cider-nrepl-middlewares connection))
;;; Dealing with compilation (evaluation) errors and warnings
(defun cider-find-property (property &optional backward)
"Find the next text region which has the specified PROPERTY.
If BACKWARD is t, then search backward.
Returns the position at which PROPERTY was found, or nil if not found."
(let ((p (if backward
(previous-single-char-property-change (point) property)
(next-single-char-property-change (point) property))))
(when (and (not (= p (point-min))) (not (= p (point-max))))
p)))
(defun cider-jump-to-compilation-error (&optional _arg _reset)
"Jump to the line causing the current compilation error.
_ARG and _RESET are ignored, as there is only ever one compilation error.
They exist for compatibility with `next-error'."
(interactive)
(cl-labels ((goto-next-note-boundary
()
(let ((p (or (cider-find-property 'cider-note-p)
(cider-find-property 'cider-note-p t))))
(when p
(goto-char p)
(message "%s" (get-char-property p 'cider-note))))))
;; if we're already on a compilation error, first jump to the end of
;; it, so that we find the next error.
(when (get-char-property (point) 'cider-note-p)
(goto-next-note-boundary))
(goto-next-note-boundary)))
(defun cider--show-error-buffer-p ()
"Return non-nil if the error buffer must be shown on error.
Takes into account both the value of `cider-show-error-buffer' and the
currently selected buffer."
(let* ((selected-buffer (window-buffer (selected-window)))
(replp (with-current-buffer selected-buffer (derived-mode-p 'cider-repl-mode))))
(memq cider-show-error-buffer
(if replp
'(t always only-in-repl)
'(t always except-in-repl)))))
(defun cider-new-error-buffer (&optional mode error-types)
"Return an empty error buffer using MODE.
When deciding whether to display the buffer, takes into account not only
the value of `cider-show-error-buffer' and the currently selected buffer
but also the ERROR-TYPES of the error, which is checked against the
`cider-stacktrace-suppressed-errors' set.
When deciding whether to select the buffer, takes into account the value of
`cider-auto-select-error-buffer'."
(if (and (cider--show-error-buffer-p)
(not (cider-stacktrace-some-suppressed-errors-p error-types)))
(cider-popup-buffer cider-error-buffer cider-auto-select-error-buffer mode 'ancillary)
(cider-make-popup-buffer cider-error-buffer mode 'ancillary)))
(defun cider-emit-into-color-buffer (buffer value)
"Emit into color BUFFER the provided VALUE."
(with-current-buffer buffer
(let ((inhibit-read-only t)
(buffer-undo-list t))
(goto-char (point-max))
(insert (format "%s" value))
(ansi-color-apply-on-region (point-min) (point-max)))
(goto-char (point-min))))
(defun cider--handle-err-eval-response (response)
"Render eval RESPONSE into a new error buffer.
Uses the value of the `out' slot in RESPONSE."
(nrepl-dbind-response response (out)
(when out
(let ((error-buffer (cider-new-error-buffer)))
(cider-emit-into-color-buffer error-buffer out)
(with-current-buffer error-buffer
(compilation-minor-mode +1))))))
(defun cider-default-err-eval-handler ()
"Display the last exception without middleware support."
(cider--handle-err-eval-response
(cider-nrepl-sync-request:eval
"(clojure.stacktrace/print-cause-trace *e)")))
(defun cider-default-err-eval-print-handler ()
"Display the last exception without middleware support.
When clojure.stracktrace is not present."
(cider--handle-err-eval-response
(cider-nrepl-sync-request:eval
"(println (ex-data *e))")))
(defun cider--render-stacktrace-causes (causes &optional error-types)
"If CAUSES is non-nil, render its contents into a new error buffer.
Optional argument ERROR-TYPES contains a list which should determine the
op/situation that originated this error."
(when causes
(let ((error-buffer (cider-new-error-buffer #'cider-stacktrace-mode error-types)))
(cider-stacktrace-render error-buffer (reverse causes) error-types))))
(defun cider--handle-stacktrace-response (response causes)
"Handle stacktrace op RESPONSE, aggregating the result into CAUSES.
If RESPONSE contains a cause, cons it onto CAUSES and return that. If
RESPONSE is the final message (i.e. it contains a status), render CAUSES
into a new error buffer."
(nrepl-dbind-response response (class msg status type)
(cond ((and (member "notification" status) causes)
(nrepl-notify msg type))
(class (cons response causes))
(status (cider--render-stacktrace-causes causes)))))
(defun cider-default-err-op-handler ()
"Display the last exception, with middleware support."
;; Causes are returned as a series of messages, which we aggregate in `causes'
(let (causes)
(cider-nrepl-send-request
(thread-last
(map-merge 'list
'(("op" "analyze-last-stacktrace"))
(cider--nrepl-print-request-map fill-column))
(seq-mapcat #'identity))
(lambda (response)
;; While the return value of `cider--handle-stacktrace-response' is not
;; meaningful for the last message, we do not need the value of `causes'
;; after it has been handled, so it's fine to set it unconditionally here
(setq causes (cider--handle-stacktrace-response response causes))))))
(defun cider-default-err-handler ()
"This function determines how the error buffer is shown.
It delegates the actual error content to the eval or op handler."
(cond ((cider-nrepl-op-supported-p "analyze-last-stacktrace")
(cider-default-err-op-handler))
((cider-library-present-p "clojure.stacktrace")
(cider-default-err-eval-handler))
(t (cider-default-err-eval-print-handler))))
;; The format of the error messages emitted by Clojure's compiler changed in
;; Clojure 1.10. That's why we're trying to match error messages to both the
;; old and the new format, by utilizing a combination of two different regular
;; expressions.
(defconst cider-clojure-1.10-error `(sequence
"Syntax error "
(minimal-match (zero-or-more anything))
"compiling "
(minimal-match (zero-or-more anything))
"at ("
(group-n 2 (minimal-match (zero-or-more anything)))
":"
(group-n 3 (one-or-more digit))
(optional ":" (group-n 4 (one-or-more digit)))
")."))
(defconst cider-clojure-1.9-error `(sequence
(zero-or-more anything)
", compiling:("
(group-n 2 (minimal-match (zero-or-more anything)))
":"
(group-n 3 (one-or-more digit))
(optional ":" (group-n 4 (one-or-more digit)))
")"))
(defconst cider-clojure-warning `(sequence
(minimal-match (zero-or-more anything))
(group-n 1 "warning")
", "
(group-n 2 (minimal-match (zero-or-more anything)))
":"
(group-n 3 (one-or-more digit))
(optional ":" (group-n 4 (one-or-more digit)))
" - "))
(defconst cider-clojure-compilation-regexp
(eval
`(rx bol (or ,cider-clojure-1.9-error
,cider-clojure-warning
,cider-clojure-1.10-error))
t))
(defvar cider-compilation-regexp
(list cider-clojure-compilation-regexp 2 3 4 '(1))
"Specifications for matching errors and warnings in Clojure stacktraces.
See `compilation-error-regexp-alist' for help on their format.")
(add-to-list 'compilation-error-regexp-alist-alist
(cons 'cider cider-compilation-regexp))
(add-to-list 'compilation-error-regexp-alist 'cider)
(defun cider-extract-error-info (regexp message)
"Extract error information with REGEXP against MESSAGE."
(let ((file (nth 1 regexp))
(line (nth 2 regexp))
(col (nth 3 regexp))
(type (nth 4 regexp))
(pat (car regexp)))
(when (string-match pat message)
;; special processing for type (1.2) style
(setq type (if (consp type)
(or (and (car type) (match-end (car type)) 1)
(and (cdr type) (match-end (cdr type)) 0)
2)))
(list
(when file
(let ((val (match-string-no-properties file message)))
(unless (string= val "NO_SOURCE_PATH") val)))
(when line (string-to-number (match-string-no-properties line message)))
(when col
(let ((val (match-string-no-properties col message)))
(when (and val (not (string-blank-p val))) (string-to-number val))))
(aref [cider-warning-highlight-face
cider-warning-highlight-face
cider-error-highlight-face]
(or type 2))
message))))
(defun cider--goto-expression-start ()
"Go to the beginning a list, vector, map or set outside of a string.
We do so by starting and the current position and proceeding backwards
until we find a delimiters that's not inside a string."
(if (and (looking-back "[])}]" (line-beginning-position))
(null (nth 3 (syntax-ppss))))
(backward-sexp)
(while (or (not (looking-at-p "[({[]"))
(nth 3 (syntax-ppss)))
(backward-char))))
(defun cider--find-last-error-location (message)
"Return the location (begin end buffer) from the Clojure error MESSAGE.
If location could not be found, return nil."
(save-excursion
(let ((info (cider-extract-error-info cider-compilation-regexp message)))
(when info
(let ((file (nth 0 info))
(line (nth 1 info))
(col (nth 2 info)))
(unless (or (not (stringp file))
(cider--tooling-file-p file))
(when-let* ((buffer (cider-find-file file)))
(with-current-buffer buffer
(save-excursion
(save-restriction
(widen)
(goto-char (point-min))
(forward-line (1- line))
(move-to-column (or col 0))
(let ((begin (progn (if col (cider--goto-expression-start) (back-to-indentation))
(point)))
(end (progn (if col (forward-list) (move-end-of-line nil))
(point))))
(list begin end buffer))))))))))))
(defun cider-handle-compilation-errors (message eval-buffer)
"Highlight and jump to compilation error extracted from MESSAGE.
EVAL-BUFFER is the buffer that was current during user's interactive
evaluation command. Honor `cider-auto-jump-to-error'."
(when-let* ((loc (cider--find-last-error-location message))
(overlay (make-overlay (nth 0 loc) (nth 1 loc) (nth 2 loc)))
(info (cider-extract-error-info cider-compilation-regexp message)))
(let* ((face (nth 3 info))
(note (nth 4 info))
(auto-jump (if (eq cider-auto-jump-to-error 'errors-only)
(not (or (eq face 'cider-warning-highlight-face)
(string-match-p "warning" note)))
cider-auto-jump-to-error)))
(overlay-put overlay 'cider-note-p t)
(overlay-put overlay 'font-lock-face face)
(overlay-put overlay 'cider-note note)
(overlay-put overlay 'help-echo note)
(overlay-put overlay 'modification-hooks
(list (lambda (o &rest _args) (delete-overlay o))))
(when auto-jump
(with-current-buffer eval-buffer
(push-mark)
;; At this stage selected window commonly is *cider-error* and we need to
;; re-select the original user window. If eval-buffer is not
;; visible it was probably covered as a result of a small screen or user
;; configuration (https://github.com/clojure-emacs/cider/issues/847). In
;; that case we don't jump at all in order to avoid covering *cider-error*
;; buffer.
(when-let* ((win (get-buffer-window eval-buffer)))
(with-selected-window win
(cider-jump-to (nth 2 loc) (car loc)))))))))
;;; Interactive evaluation handlers
(defun cider-insert-eval-handler (&optional buffer)
"Make an nREPL evaluation handler for the BUFFER.
The handler simply inserts the result value in BUFFER."
(let ((eval-buffer (current-buffer))
(res ""))
(nrepl-make-response-handler (or buffer eval-buffer)
(lambda (_buffer value)
(with-current-buffer buffer
(insert value))
(when cider-eval-register
(setq res (concat res value))))
(lambda (_buffer out)
(cider-repl-emit-interactive-stdout out))
(lambda (_buffer err)
(cider-handle-compilation-errors err eval-buffer))
(lambda (_buffer)
(when cider-eval-register
(set-register cider-eval-register res))))))
(defun cider--emit-interactive-eval-output (output repl-emit-function)
"Emit output resulting from interactive code evaluation.
The OUTPUT can be sent to either a dedicated output buffer or the current
REPL buffer. This is controlled by `cider-interactive-eval-output-destination'.
REPL-EMIT-FUNCTION emits the OUTPUT."
(pcase cider-interactive-eval-output-destination
(`output-buffer (let ((output-buffer (or (get-buffer cider-output-buffer)
(cider-popup-buffer cider-output-buffer t))))
(cider-emit-into-popup-buffer output-buffer output)
(pop-to-buffer output-buffer)))
(`repl-buffer (funcall repl-emit-function output))
(_ (error "Unsupported value %s for `cider-interactive-eval-output-destination'"
cider-interactive-eval-output-destination))))
(defun cider-emit-interactive-eval-output (output)
"Emit OUTPUT resulting from interactive code evaluation.
The output can be send to either a dedicated output buffer or the current
REPL buffer. This is controlled via
`cider-interactive-eval-output-destination'."
(cider--emit-interactive-eval-output output 'cider-repl-emit-interactive-stdout))
(defun cider-emit-interactive-eval-err-output (output)
"Emit err OUTPUT resulting from interactive code evaluation.
The output can be send to either a dedicated output buffer or the current
REPL buffer. This is controlled via
`cider-interactive-eval-output-destination'."
(cider--emit-interactive-eval-output output 'cider-repl-emit-interactive-stderr))
(defun cider--make-fringe-overlays-for-region (beg end)
"Place eval indicators on all sexps between BEG and END."
(with-current-buffer (if (markerp end)
(marker-buffer end)
(current-buffer))
(save-excursion
(goto-char beg)
(remove-overlays beg end 'category 'cider-fringe-indicator)
(condition-case nil
(while (progn (clojure-forward-logical-sexp)
(and (<= (point) end)
(not (eobp))))
(cider--make-fringe-overlay (point)))
(scan-error nil)))))
(declare-function cider-inspect-last-result "cider-inspector")
(defun cider-interactive-eval-handler (&optional buffer place)
"Make an interactive eval handler for BUFFER.
PLACE is used to display the evaluation result.
If non-nil, it can be the position where the evaluated sexp ends,
or it can be a list with (START END) of the evaluated region.
Update the cider-inspector buffer with the evaluation result
when `cider-auto-inspect-after-eval' is non-nil."
(let* ((eval-buffer (current-buffer))
(beg (car-safe place))
(end (or (car-safe (cdr-safe place)) place))
(beg (when beg (copy-marker beg)))
(end (when end (copy-marker end)))
(fringed nil)
(res ""))
(nrepl-make-response-handler (or buffer eval-buffer)
(lambda (_buffer value)
(setq res (concat res value))
(cider--display-interactive-eval-result res end))
(lambda (_buffer out)
(cider-emit-interactive-eval-output out))
(lambda (_buffer err)
(cider-emit-interactive-eval-err-output err)
(when (or (not cider-show-error-buffer)
(not (cider-connection-has-capability-p 'jvm-compilation-errors)))
;; Display errors as temporary overlays
(let ((cider-result-use-clojure-font-lock nil))
(cider--display-interactive-eval-result
err end 'cider-error-overlay-face)))
(cider-handle-compilation-errors err eval-buffer))
(lambda (buffer)
(if beg
(unless fringed
(cider--make-fringe-overlays-for-region beg end)
(setq fringed t))
(cider--make-fringe-overlay end))
(when (and cider-auto-inspect-after-eval
(boundp 'cider-inspector-buffer)
(windowp (get-buffer-window cider-inspector-buffer 'visible)))
(cider-inspect-last-result)
(select-window (get-buffer-window buffer)))
(when cider-eval-register
(set-register cider-eval-register res))))))
(defun cider-load-file-handler (&optional buffer done-handler)
"Make a load file handler for BUFFER.
Optional argument DONE-HANDLER lambda will be run once load is complete."
(let ((eval-buffer (current-buffer))
(res ""))
(nrepl-make-response-handler (or buffer eval-buffer)
(lambda (buffer value)
(cider--display-interactive-eval-result value)
(when cider-eval-register
(setq res (concat res value)))
(when (buffer-live-p buffer)
(with-current-buffer buffer
(cider--make-fringe-overlays-for-region (point-min) (point-max))
(run-hooks 'cider-file-loaded-hook))))
(lambda (_buffer value)
(cider-emit-interactive-eval-output value))
(lambda (_buffer err)
(cider-emit-interactive-eval-err-output err)
(cider-handle-compilation-errors err eval-buffer))
(lambda (buffer)
(when cider-eval-register
(set-register cider-eval-register res))
(when done-handler
(funcall done-handler buffer)))
(lambda ()
(funcall nrepl-err-handler)))))
(defun cider-eval-print-handler (&optional buffer)
"Make a handler for evaluating and printing result in BUFFER."
;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
;; See https://github.com/clojure-emacs/cider/pull/3162
(nrepl-make-response-handler (or buffer (current-buffer))
(lambda (buffer value)
(with-current-buffer buffer
(insert
(if (derived-mode-p 'cider-clojure-interaction-mode)
(format "\n%s\n" value)
value))))
(lambda (_buffer out)
(cider-emit-interactive-eval-output out))
(lambda (_buffer err)
(cider-emit-interactive-eval-err-output err))
()))
(defun cider-eval-print-with-comment-handler (buffer location comment-prefix)
"Make a handler for evaluating and printing commented results in BUFFER.
LOCATION is the location marker at which to insert. COMMENT-PREFIX is the
comment prefix to use."
(let ((res ""))
(nrepl-make-response-handler buffer
(lambda (_buffer value)
(setq res (concat res value)))
(lambda (_buffer out)
(cider-emit-interactive-eval-output out))
(lambda (_buffer err)
(cider-emit-interactive-eval-err-output err))
(lambda (buffer)
(with-current-buffer buffer
(save-excursion
(goto-char (marker-position location))
(insert (concat comment-prefix
res "\n"))))
(when cider-eval-register
(set-register cider-eval-register res))))))
(defun cider-maybe-insert-multiline-comment (result comment-prefix continued-prefix comment-postfix)
"Insert eval RESULT at current location if RESULT is not empty.
RESULT will be preceded by COMMENT-PREFIX.
CONTINUED-PREFIX is inserted for each additional line of output.
COMMENT-POSTFIX is inserted after final text output."
(unless (string= result "")
(clojure-indent-line)
(let ((lines (split-string result "[\n]+" t))
(beg (point))
(col (current-indentation)))
;; only the first line gets the normal comment-prefix
(insert (concat comment-prefix (pop lines)))
(dolist (elem lines)
(insert (concat "\n" continued-prefix elem)))
(indent-rigidly beg (point) col)
(unless (string= comment-postfix "")
(insert comment-postfix)))))
(defun cider-eval-pprint-with-multiline-comment-handler (buffer location comment-prefix continued-prefix comment-postfix)
"Make a handler for evaluating and inserting results in BUFFER.
The inserted text is pretty-printed and region will be commented.
LOCATION is the location marker at which to insert.
COMMENT-PREFIX is the comment prefix for the first line of output.
CONTINUED-PREFIX is the comment prefix to use for the remaining lines.
COMMENT-POSTFIX is the text to output after the last line."
(let ((res ""))
(nrepl-make-response-handler
buffer
(lambda (_buffer value)
(setq res (concat res value)))
nil
(lambda (_buffer err)
(setq res (concat res err)))
(lambda (buffer)
(with-current-buffer buffer
(save-excursion
(goto-char (marker-position location))
;; edge case: defun at eob
(unless (bolp) (insert "\n"))
(cider-maybe-insert-multiline-comment res comment-prefix continued-prefix comment-postfix)))
(when cider-eval-register
(set-register cider-eval-register res)))
nil
nil
(lambda (_buffer warning)
(setq res (concat res warning))))))
(defun cider-popup-eval-handler (&optional buffer)
"Make a handler for printing evaluation results in popup BUFFER.
This is used by pretty-printing commands."
;; NOTE: cider-eval-register behavior is not implemented here for performance reasons.
;; See https://github.com/clojure-emacs/cider/pull/3162
(nrepl-make-response-handler
(or buffer (current-buffer))
(lambda (buffer value)
(cider-emit-into-popup-buffer buffer (ansi-color-apply value) nil t))
(lambda (_buffer out)
(cider-emit-interactive-eval-output out))
(lambda (_buffer err)
(cider-emit-interactive-eval-err-output err))
nil
nil
nil
(lambda (buffer warning)
(cider-emit-into-popup-buffer buffer warning 'font-lock-warning-face t))))
;;; Interactive valuation commands
(defvar cider-to-nrepl-filename-function
(with-no-warnings
(lambda (path)
(let ((path* (if (eq system-type 'cygwin)
(cygwin-convert-file-name-to-windows path)
path)))
(or (cider--translate-path-to-nrepl path*) path*))))
"Function to translate Emacs filenames to nREPL namestrings.")
(defun cider--prep-interactive-eval (form connection)
"Prepare the environment for an interactive eval of FORM in CONNECTION.
Ensure the current ns declaration has been evaluated (so that the ns
containing FORM exists). Cache ns-form in the current buffer unless FORM is
ns declaration itself. Clear any compilation highlights and kill the error
window."
(cider--clear-compilation-highlights)
(cider--quit-error-window)
(let ((cur-ns-form (cider-ns-form)))
(when (and cur-ns-form
(not (cider-ns-form-p form))
(cider-repl--ns-form-changed-p cur-ns-form connection))
(when cider-auto-track-ns-form-changes
;; The first interactive eval on a file can load a lot of libs. This can
;; easily lead to more than 10 sec.
(let ((nrepl-sync-request-timeout 30))
;; TODO: check for evaluation errors
(cider-nrepl-sync-request:eval cur-ns-form connection)))
;; cache at the end, in case of errors
(cider-repl--cache-ns-form cur-ns-form connection))))
(defvar-local cider-interactive-eval-override nil
"Function to call instead of `cider-interactive-eval'.")
(defun cider-interactive-eval (form &optional callback bounds additional-params)
"Evaluate FORM and dispatch the response to CALLBACK.
If the code to be evaluated comes from a buffer, it is preferred to use a
nil FORM, and specify the code via the BOUNDS argument instead.
This function is the main entry point in CIDER's interactive evaluation
API. Most other interactive eval functions should rely on this function.
If CALLBACK is nil use `cider-interactive-eval-handler'.
BOUNDS, if non-nil, is a list of two numbers marking the start and end
positions of FORM in its buffer.
ADDITIONAL-PARAMS is a map to be merged into the request message.
If `cider-interactive-eval-override' is a function, call it with the same
arguments and only proceed with evaluation if it returns nil."
(let ((form (or form (apply #'buffer-substring-no-properties bounds)))
(start (car-safe bounds))
(end (car-safe (cdr-safe bounds))))
(when (and start end)
;; NOTE: don't use `remove-overlays' as it splits and leaves behind
;; partial overlays, leading to duplicate eval results in some situations.
(dolist (ov (overlays-in start end))
(when (eq (overlay-get ov 'cider-temporary) t)
(delete-overlay ov))))
(unless (and cider-interactive-eval-override
(functionp cider-interactive-eval-override)
(funcall cider-interactive-eval-override form callback bounds))
(cider-map-repls :auto
(lambda (connection)
(cider--prep-interactive-eval form connection)
(cider-nrepl-request:eval
form
(or callback (cider-interactive-eval-handler nil bounds))
;; always eval ns forms in the user namespace
;; otherwise trying to eval ns form for the first time will produce an error
(if (cider-ns-form-p form) "user" (cider-current-ns))
(when start (line-number-at-pos start))
(when start (cider-column-number-at-pos start))
(seq-mapcat #'identity additional-params)
connection))))))
(defun cider-eval-region (start end)
"Evaluate the region between START and END."
(interactive "r")
(cider-interactive-eval nil
nil
(list start end)
(cider--nrepl-pr-request-map)))
(defun cider-eval-last-sexp (&optional output-to-current-buffer)
"Evaluate the expression preceding point.
If invoked with OUTPUT-TO-CURRENT-BUFFER, print the result in the current
buffer."
(interactive "P")
(cider-interactive-eval nil
(when output-to-current-buffer (cider-eval-print-handler))
(cider-last-sexp 'bounds)