       ;; Be careful not to split an escape sequence.
       (if (paredit-in-string-escape-p)
           (backward-char))
-      (let ((beginning (point)))
-        (while (not (or (eolp)
-                        (eq (char-after) ?\" )))
-          (forward-char)
-          ;; Skip past escaped characters.
-          (if (eq (char-before) ?\\ )
-              (forward-char)))
-        (kill-region beginning (point))))))
+      (kill-region (point)
+                   (min (point-at-eol)
+                        (cdr (paredit-string-start+end-points)))))))
 
 (defun paredit-kill-sexps-on-line ()
   (if (paredit-in-char-p)               ; Move past the \ and prefix.

                 "(string #\\x|)")
                ("\"foo|bar\"\n  ; Escaping character... (\")"
                 "\"foo\\\"|bar\""))
   ("M-;"       paredit-comment-dwim
                ("(foo |bar)   ; baz"
                 "(foo bar)                               ; |baz")

  (interactive "P")
  (if (paredit-in-string-p)
      (paredit-splice-string argument)
      (save-excursion
        (paredit-kill-surrounding-sexps-for-splice argument)
        (let ((end (point)))
          (backward-up-list)            ; Go up to the beginning...
          (save-excursion
            (forward-char 1)            ; (Skip over leading whitespace
            (paredit-skip-whitespace t end)
            (setq end (point)))         ;   for the `delete-region'.)
          (let ((indent-start nil) (indent-end nil))
            (save-excursion
              (setq indent-start (point))
              (forward-sexp)            ; Go forward an expression, to
              (backward-delete-char 1)  ;   delete the end delimiter.
              (setq indent-end (point)))
            (delete-region (point) end) ; ...to delete the open char.
            ;; Reindent only the region we preserved.
            (indent-region indent-start indent-end))))))

(defun paredit-kill-surrounding-sexps-for-splice (argument)
  (cond ((or (paredit-in-string-p)
