Many changes

elisp/inferior-jshell.el

@@ -224,7 +224,9 @@ the arguments to pass.  They default to `jshell-switches'."
         (goto-char (point-max))
         (insert code)
         (goto-char (point-max))
-        (jshell-send-input)
+        ;; don't save history
+        (let ((comint-input-filter #'ignore))
+          (jshell-send-input))
         (goto-char (point-max))
         (insert old)
         (goto-char (point-max))))))
@@ -252,6 +254,11 @@ START and END default to the current region."
   "Send the Java expression under point to a live JShell buffer.
 This only works in `java-ts-mode'."
   (interactive)
+  (save-excursion
+    (let ((start (point)))
+      (back-to-indentation)
+      (unless (> (point) start)
+        (goto-char start)))
     (let ((root (treesit-buffer-root-node)))
       (let ((node (car (or (treesit-query-range
                             root '([(expression_statement)
@@ -280,7 +287,7 @@ This only works in `java-ts-mode'."
                                   ")" (* (syntax whitespace)) eos)
                               text)
             (setq text (match-string 1 text)))
-        (jshell-eval text)))))
+          (jshell-eval text))))))
 
 
 (provide 'inferior-jshell)

init.el

@@ -2093,6 +2093,9 @@ Note that this erases the buffer before doing anything."
   (advice-add 'jupyter-kernel-language-mode-properties
               :filter-return #'my/-jupyter-dont-use-ts-modes)
   :config
+  (face-spec-set 'jupyter-repl-traceback
+                 '((default . (:background unspecified)))
+                 'face-override-spec)
   (defun company-doc-buffer (&optional string)
     "Emulate company's `company-doc-buffer'."
     (with-current-buffer (get-buffer-create "*company-documentation*")
@@ -2133,8 +2136,10 @@ Note that this erases the buffer before doing anything."
                            (with-current-buffer buf
                              (and (derived-mode-p 'jupyter-repl-mode)
                                   jupyter-current-client
-                                  (eq lang (jupyter-kernel-language
+                                  (cl-equalp lang
-                                            jupyter-current-client)))))
+                                             (symbol-name
+                                              (jupyter-kernel-language
+                                               jupyter-current-client))))))
                          (buffer-list))))
     (when-let (((not res))
                (real (alist-get lang my/jupyter-extra-language-associations)))
@@ -2146,9 +2151,8 @@ Note that this erases the buffer before doing anything."
 MODE defaults to `major-mode'."
   (when-let ((name (symbol-name (or mode major-mode)))
              ((string-match (rx bos (group (+? any)) (? "-ts") "-mode" eos)
-                            name))
+                            name)))
-             (sym (intern-soft (match-string 1 name))))
+    (my/-find-jupyter-buffer-for-lang (match-string 1 name))))
-    (my/-find-jupyter-buffer-for-lang sym)))
 
 (defun my/-jupyter-find-proper-buffer ()
   "Find the buffer for `my/jupyter-eval-in-proper-buffer'."
@@ -2178,7 +2182,7 @@ current buffer is a Jupyter buffer, just use that."
     (unless no-error (user-error "No Jupyter buffer found for mode: %s"
                                  major-mode))))
 
-(defun my/c++-ts-jupyter-eval-defun ()
+(defun my/jupyter-eval-defun ()
   "Eval the defun under point by sending it to a Jupyter repl."
   (interactive)
   (if-let ((code (thing-at-point 'defun)))
@@ -2187,9 +2191,25 @@ current buffer is a Jupyter buffer, just use that."
         (message "Evaluated defun"))
     (user-error "Nothing to evaluate under point")))
 
+(defun my/jupyter-eval-buffer ()
+  "Eval the current buffer by sending it to a Jupyter repl."
+  (interactive)
+  (my/jupyter-eval-in-proper-buffer (buffer-substring-no-properties
+                                     (point-min) (point-max)))
+  (message "Evaluated buffer"))
+
+(defun my/c++-jupyter-eval-region (start end)
+  "Send the current buffer between START and END to a Jupyter repl."
+  (interactive "r")
+  (let ((code (buffer-substring-no-properties start end)))
+    (when (string-suffix-p ";" code)
+      (setq code (substring code 0 (1- (length code)))))
+    (my/jupyter-eval-in-proper-buffer code)
+    (message "Evaluated region")))
+
 (defun my/c++-ts-jupyter-eval-expression ()
   "Eval the expression under point by sending it to a Jupyter repl."
-  (interactive)
+  (interactive nil c-ts-mode c++-ts-mode)
   (save-excursion
     (let ((start (point)))
       (back-to-indentation)
@@ -2219,34 +2239,47 @@ current buffer is a Jupyter buffer, just use that."
           (message "Evaluated: %s" code))
       (user-error "Nothing to evaluate under point"))))
 
-(defun my/c++-ts-jupyter-eval-region ()
+(defun my/rust-jupyter-eval-region (start end)
-  "Eval the region by sending it to a Jupyter repl."
+  "Send the current buffer between START and END to a Jupyter repl."
-  (interactive)
+  (interactive "r")
-  (if mark-active
+  (let ((code (buffer-substring-no-properties start end)))
-      (let ((code (buffer-substring-no-properties (region-beginning)
-                                                  (region-end))))
-        (when (string-suffix-p ";" code)
-          (setq code (substring code 0 (1- (length code)))))
     (my/jupyter-eval-in-proper-buffer code)
-        (message "Evaluated region"))
+    (message "Evaluated region")))
-    (user-error "No active region")))
 
-(defun my/c++-ts-jupyter-eval-buffer ()
+(defun my/rust-ts-jupyter-eval-expression ()
-  "Eval the current buffer by sending it to a Jupyter repl."
+  "Eval the expression under point by sending it to a Jupyter repl."
-  (interactive)
+  (interactive nil rust-ts-mode)
-  (my/jupyter-eval-in-proper-buffer (buffer-substring-no-properties
+  (save-excursion
-                                     (point-min) (point-max)))
+    (let ((start (point)))
-  (message "Evaluated buffer"))
+      (back-to-indentation)
+      (unless (> (point) start)
+        (goto-char start)))
+    (if-let ((thing (treesit-thing-at-point "_" 'nested))
+             (code (treesit-node-text thing)))
+        (progn
+          (my/jupyter-eval-in-proper-buffer code)
+          (message "Evaluated: %s" code))
+      (user-error "Nothing to evaluate under point"))))
 
 (with-eval-after-load 'c-ts-mode
   (keymap-set c-ts-base-mode-map
-              "C-M-x" #'my/c++-ts-jupyter-eval-defun)
+              "C-M-x" #'my/jupyter-eval-defun)
   (keymap-set c-ts-base-mode-map
               "C-c C-e" #'my/c++-ts-jupyter-eval-expression)
   (keymap-set c-ts-base-mode-map
-              "C-c C-r" #'my/c++-ts-jupyter-eval-region)
+              "C-c C-r" #'my/c++-jupyter-eval-region)
   (keymap-set c-ts-base-mode-map
-              "C-c C-b" #'my/c++-ts-jupyter-eval-buffer))
+              "C-c C-b" #'my/jupyter-eval-buffer))
+
+(with-eval-after-load 'rust-ts-mode
+  (keymap-set rust-ts-mode-map
+              "C-M-x" #'my/jupyter-eval-defun)
+  (keymap-set rust-ts-mode-map
+              "C-c C-e" #'my/rust-ts-jupyter-eval-expression)
+  (keymap-set rust-ts-mode-map
+              "C-c C-r" #'my/rust-jupyter-eval-region)
+  (keymap-set rust-ts-mode-map
+              "C-c C-b" #'my/jupyter-eval-buffer))
 
 ;; pdf-tools
 (use-package pdf-tools
@@ -3057,6 +3090,61 @@ buffers `helpful--sym' to `my/helpful-symbol-history'."
   (setq helpful-switch-buffer-function 'my/-helpful-switch-buffer-function
         helpful-max-buffers 2))
 
+;; useful for debugging
+(defun my/describe-symbol-plist (symbol)
+  "Descrive the plist of SYMBOL in a buffer."
+  (interactive (list (intern (completing-read
+                              "Symbol: "
+                              (let ((syms))
+                                (mapatoms (##push (symbol-name %) syms))
+                                syms)
+                              nil t))))
+  (with-current-buffer (get-buffer-create "*describe-symbol-plist*")
+    (unless (derived-mode-p 'special-mode)
+      (special-mode))
+    (let ((inhibit-read-only t)
+          (keys)
+          (values))
+      (map-do (lambda (k v)
+                (push k keys)
+                (push v values))
+              (symbol-plist symbol))
+      (setq keys (nreverse keys)
+            values (nreverse values))
+      (erase-buffer)
+      (insert (propertize "Plist of "
+                          'face 'shortdoc-heading))
+      (insert (propertize (format "%S" symbol)
+                          'face '((:weight normal) shortdoc-heading)))
+      (insert "\n\n")
+      (with-temp-buffer
+        (let ((delayed-mode-hooks nil))
+          (delay-mode-hooks
+            (lisp-mode))
+          (font-lock-mode)
+          (show-paren-mode)
+          (when (fboundp 'rainbow-delimiters-mode)
+            (rainbow-delimiters-mode)))
+        (let ((pp-max-width fill-column)
+              (pp-use-max-width t))
+          (setq values (mapcar (lambda (val)
+                                 (erase-buffer)
+                                 (pp val (current-buffer))
+                                 (font-lock-ensure)
+                                 (buffer-string))
+                               values))))
+      (goto-char (point-max))
+      (cl-loop for key in keys
+               for value in values
+               do
+               (insert (propertize (prin1-to-string key)
+                                   'face 'bold))
+               (insert "\n")
+               (insert value)
+               (insert "\n"))
+      (delete-char -1))
+    (pop-to-buffer (current-buffer))))
+
 (defun my/greyify-color (color percent &optional frame)
   "Make COLOR closer to black by PERCENT on FRAME.
 Color can be any color which can be passed to `color-values'."