srefactor-lisp.el

;;; Srefactor --- A refactoring tool based on Semantic parser framework
;;
;; Filename: srefactor-lisp.el
;; Description: A refactoring tool based on Semantic parser framework
;; Author: Tu, Do Hoang <tuhdo1710@gmail.com>
;; URL      : https://github.com/tuhdo/semantic-refactor
;; Maintainer: Tu, Do Hoang
;; Created: Wed Feb 11 21:25:51 2015 (+0700)
;; Version: 0.3
;; Package-Requires: ((emacs "24.3+"))
;; Last-Updated: Wed Feb 11 21:25:51 2015 (+0700)
;;           By: Tu, Do Hoang
;;     Update #: 1
;; URL:
;; Doc URL:
;; Keywords: emacs-lisp, languages, tools
;; Compatibility: GNU Emacs: 24.3+
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; Semantic is a package that provides a framework for writing
;; parsers. Parsing is a process of analyzing source code based on
;; programming language syntax. This package relies on Semantic for
;; analyzing source code and uses its results to perform smart code
;; refactoring that based on code structure of the analyzed language,
;; instead of plain text structure.
;;
;; This package provides the following features for Emacs Lisp:
;;
;; - `srefactor-lisp-format-buffer': Format whole buffer.
;; - `srefactor-lisp-format-defun': Format the current defun point is in.
;; - `srefactor-lisp-one-line': Transform all sub-sexpressions current sexpression at
;; point into one line separated each one by a space.
;;
;; - `srefactor-lisp-format-sexp': Transform all sub-sexpressions current sexpression
;; at point into multiple lines separated. If the head symbol belongs to the
;; list `srefactor-lisp-symbol-to-skip', then the first N next symbol/sexpressions
;; (where N is the nummber associated with the head symbol as stated in the
;;  list) are skipped before a newline is inserted.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:
(require 'semantic/bovine/el)

(defcustom srefactor-newline-threshold 40
  "If a token is about to be inserted, if the current posistion
  exceeds this threshold characters, insert the token in the next
  line isntead. Note that this does not account for indentation
  but the total number of characters in a line."
  :group 'srefactor)

(defcustom srefactor-lisp-symbol-to-skip '(("progn" . 0)
                                           ("cond" . 0)
                                           ("save-excursion" . 0)
                                           ("unwind-protect" . 0)
                                           ("with-temp-buffer" . 0)
                                           ;; ("condition-case" . 1)
                                           ;; ("with-current-buffer" . 1)
                                           ;; ("with-open-file" . 1)
                                           ;; ("let" . 1)
                                           ;; ("let*" . 1)
                                           ;; ("if" . 1)
                                           ;; ("while" . 1)
                                           ;; ("dolist" . 1)
                                           ;; ("do" . 1)
                                           ;; ("when" . 1)
                                           ;; ("buffer-substring-no-properties" . 1)
                                           ;; ("unless" . 1)
                                           ;; ("not" . 1)
                                           ;; ("null" . 1)
                                           ;; ("null?" . 1)
                                           ;; ("concat" . 1)
                                           ;; ("or" . 1)
                                           ;; ("and" . 1)
                                           ;; ("catch" . 1)
                                           ;; ("mapcar" . 1)
                                           ;; ("mapcan" . 1)
                                           ;; ("mapc" . 1)
                                           ;; ("+" . 1)
                                           ;; ("-" . 1)
                                           ;; ("*" . 1)
                                           ;; ("/" . 1)
                                           ;; ("error" . 1)
                                           ;; ("goto-char" . 1)
                                           ;; ("insert" . 1)
                                           ;; ("car" . 1)
                                           ;; ("cdr" . 1)
                                           ;; ("lambda" . 1)
                                           ;; ("1+" . 1)
                                           ;; ("1-" . 1)
                                           ("defmethod" . 1)
                                           ("cons" . 2)
                                           ("kill-region" . 2)
                                           ("equal" . 2)
                                           ("member" . 2)
                                           ("eq?" . 2)
                                           ("eq" . 2)
                                           ("get" . 2)
                                           ("assoc" . 2)
                                           ("defun" . 2)
                                           ("defclass" . 2)
                                           ("defstruct" . 2)
                                           ("defmacro" . 2)
                                           ("defsubst" . 2)
                                           ("defface" . 2)
                                           ("defalias" . 2)
                                           ("defcustom" . 2)
                                           ("declare" . 2)
                                           ("defvar" . 2)
                                           ("defparameter" . 2)
                                           ("defconst" . 2)
                                           ("string-match" . 2)
                                           ("defcustom" . 2)
                                           ("setq" . 2)
                                           ("setq-default" . 2)
                                           ("member" . 2)
                                           ("setf" . 2)
                                           (">" . 2)
                                           ("<" . 2)
                                           ("<=" . 2)
                                           (">=" . 2)
                                           ("/=" . 2)
                                           ("=" . 2)
                                           ("some" . 2)
                                           ("define-key" . 3)
                                           ("modify-syntax-entry" . 3))
  "A list of pairs of a symbol and a number that denotes how many
  sexp to skip before inserting the first newline. "
  :group 'srefactor)

(defcustom srefactor-clojure-symbol-to-skip '(("fn" . 1)
                                              ("ns" . 1)
                                              (":require" . 1)
                                              (":import" . 1)
                                              ("def" . 2)
                                              ("struct-map" . 1)
                                              ("defmacro" . 1)
                                              ("binding" . 1)
                                              ("with-bindings" . 1)
                                              ("doseq" . 1)
                                              ("catch" . 2)
                                              ("defn" . 2))
  "A list of pairs of a symbol and a number that denotes how many
  sexp to skip before inserting a newline. This will be merged
  with `srefactor-lisp-symbol-to-skip'. Symbols in this list
  overrides symbols in `srefactor-lisp-symbol-to-skip'."
  :group 'srefactor)

;; Internal variables of parser state
(defvar token nil)
(defvar token-type nil)
(defvar token-str nil)
(defvar ignore-num nil)
(defvar tok-start nil)
(defvar next-token nil)
(defvar next-token-start nil)
(defvar next-token-end nil)
(defvar next-token-type nil)
(defvar next-token-str nil)
(defvar tok-end nil)
(defvar cur-buf nil)
(defvar first-token nil)
(defvar first-token-name nil)
(defvar second-token nil)
(defvar lexemes nil)
(defvar comment-token nil)
(defvar comment-content nil)
(defvar token-real-line nil)
(defvar next-token-real-line nil)
(defvar comment-real-line-start nil)
(defvar comment-real-line-end nil)
(defvar comment-token-start nil)
(defvar comment-token-end nil)
(defvar format-type nil)
(defvar recursive-p nil)
(defvar orig-format-type nil)


(defun srefactor--appropriate-major-mode (major-mode)
  (cond
   ((eq major-mode 'emacs-lisp-mode)
    (emacs-lisp-mode))
   ((eq major-mode 'scheme-mode)
    (scheme-mode))
   ((eq major-mode 'common-lisp-mode)
    (common-lisp-mode))
   ((and (fboundp 'clojure-mode)
         (eq major-mode 'clojure-mode))
    (clojure-mode))
   (t (emacs-lisp-mode))))

(defun srefactor--define-skip-list-for-mode (major-mode)
  (cond
   ((and (fboundp 'clojure-mode)
         (eq major-mode 'clojure-mode))
    (cl-remove-duplicates (append srefactor-lisp-symbol-to-skip srefactor-clojure-symbol-to-skip)
                          :test (lambda (a b)
                                  (equal (car a) (car b)))))
   (t srefactor-lisp-symbol-to-skip)))

(defun srefactor-lisp-format-buffer ()
  "Format current buffer."
  (interactive)
  (let ((cur-pos (point))
        (buf-content (buffer-substring-no-properties (point-min)
                                                     (point-max)))
        (cur-major-mode major-mode)
        (orig-skip-list srefactor-lisp-symbol-to-skip)
        (cur-indent-mode indent-tabs-mode))
    (setq buf-content (with-temp-buffer
                        (semantic-default-elisp-setup)
                        (emacs-lisp-mode)
                        (setq indent-tabs-mode cur-indent-mode)
                        (setq srefactor-lisp-symbol-to-skip (srefactor--define-skip-list-for-mode cur-major-mode))
                        (semantic-lex-init)
                        (insert buf-content)
                        (goto-char (point-max))
                        (while (beginning-of-defun-raw)
                          (let ((beg (point))
                                (end (save-excursion
                                       (forward-sexp)
                                       (point))))
                            (srefactor--lisp-format-one-or-multi-lines
                             beg end beg 'multi-line nil t)
                            (goto-char beg)))
                        (srefactor--appropriate-major-mode cur-major-mode)
                        (indent-region (point-min)
                                       (point-max))
                        (setq srefactor-lisp-symbol-to-skip orig-skip-list)
                        (buffer-substring-no-properties (point-min)
                                                        (point-max))))
    (kill-region (point-min) (point-max))
    (insert buf-content)
    (goto-char cur-pos)))

(defun srefactor-lisp-format-defun ()
  "Format current defun point is in."
  (interactive)
  (let* ((orig-point (point))
         (beg (save-excursion
                (forward-char 1)
                (beginning-of-defun-raw)
                (point)))
         (end (save-excursion
                (goto-char beg)
                (forward-sexp)
                (point)))
         (orig-skip-list srefactor-lisp-symbol-to-skip)
         (cur-indent-mode indent-tabs-mode)
         (cur-major-mode major-mode)
         (content (buffer-substring-no-properties beg end)))
    (progn
      (setq content (with-temp-buffer
                      (semantic-default-elisp-setup)
                      (emacs-lisp-mode)
                      (setq indent-tabs-mode cur-indent-mode)
                      (setq srefactor-lisp-symbol-to-skip (srefactor--define-skip-list-for-mode cur-major-mode))
                      (semantic-lex-init)
                      (insert content)
                      (srefactor--lisp-format-one-or-multi-lines (point-min)
                                                                 (point-max)
                                                                 (point-min)'multi-line
                                                                 nil
                                                                 t)
                      (srefactor--appropriate-major-mode cur-major-mode)
                      (setq srefactor-lisp-symbol-to-skip orig-skip-list)
                      (indent-region (point-min)
                                     (point-max))
                      (buffer-substring-no-properties (point-min)
                                                      (point-max))))
      (kill-region beg end)
      (insert content)
      (goto-char orig-point))))

(defun srefactor-lisp-format-sexp ()
  "Transform all sub-sexpressions current sexpression at point
into multiple lines separatedly. If the head symbol belongs to the
list `srefactor-lisp-symbol-to-skip', then the first N next
symbol/sexpressions (where N is the nummber associated with the
head symbol as stated in the list) are skipped before a newline
is inserted."
  (interactive)
  (let* ((orig-point (point))
         (beg (save-excursion
                (unless (looking-at "[({[]")
                  (backward-up-list))
                (point)))
         (end (save-excursion
                (goto-char beg)
                (forward-sexp)
                (point)))
         (orig-skip-list srefactor-lisp-symbol-to-skip)
         (cur-indent-mode indent-tabs-mode)
         (cur-major-mode major-mode)
         (content (buffer-substring-no-properties beg end)))
    (progn
      (setq content (with-temp-buffer
                      (semantic-default-elisp-setup)
                      (emacs-lisp-mode)
                      (setq indent-tabs-mode cur-indent-mode)
                      (setq srefactor-lisp-symbol-to-skip (srefactor--define-skip-list-for-mode cur-major-mode))
                      (semantic-lex-init)
                      (insert content)
                      (srefactor--lisp-format-one-or-multi-lines (point-min)
                                                                 (point-max)
                                                                 (point-min)'multi-line
                                                                 nil
                                                                 t)
                      (srefactor--appropriate-major-mode cur-major-mode)
                      (setq srefactor-lisp-symbol-to-skip orig-skip-list)
                      (buffer-substring-no-properties (point-min)
                                                      (point-max))))
      (kill-region beg end)
      (insert content)
      (goto-char beg)
      (forward-sexp)
      (setq end (point))
      (indent-region beg end)
      (goto-char orig-point))))

(defun srefactor-lisp-one-line (recursive-p)
  "Transform all sub-sexpressions current sexpression at point
into one line separated each one by a space."
  (interactive "P")
  (let* ((orig-point (point))
         (beg (save-excursion
                (unless (looking-at "[({[]")
                  (backward-up-list))
                (point)))
         (end (save-excursion
                (goto-char beg)
                (forward-sexp)
                (point)))
         (orig-skip-list srefactor-lisp-symbol-to-skip)
         (cur-indent-mode indent-tabs-mode)
         (cur-major-mode major-mode)
         (content (buffer-substring-no-properties beg end)))
    (progn
      (setq content (with-temp-buffer
                      (semantic-default-elisp-setup)
                      (emacs-lisp-mode)
                      (setq indent-tabs-mode cur-indent-mode)
                      (setq srefactor-lisp-symbol-to-skip (srefactor--define-skip-list-for-mode cur-major-mode))
                      (semantic-lex-init)
                      (insert content)
                      (srefactor--lisp-format-one-or-multi-lines (point-min)
                                                                 (point-max)
                                                                 (point-min)'one-line
                                                                 nil
                                                                 recursive-p)
                      (srefactor--appropriate-major-mode cur-major-mode)
                      (setq srefactor-lisp-symbol-to-skip orig-skip-list)
                      (indent-region (point-min)
                                     (point-max))
                      (buffer-substring-no-properties (point-min)
                                                      (point-max))))
      (kill-region beg end)
      (insert content)
      (goto-char orig-point))))

(defun srefactor--lisp-format-one-or-multi-lines (beg end orig-point format-type &optional
                                                      newline-betwen-semantic-lists recursive-p)
  "Turn the current sexpression into one line/multi-line depends
on the value of FORMAT-TYPE. If FORMAT-TYPE is 'one-line,
transforms all sub-sexpressions of the same level into one
line. If FORMAT-TYPE is 'multi-line, transforms all
sub-sexpressions of the same level into multiple lines.

Return the position of last closing sexp."
  (let* ((lexemes (semantic-emacs-lisp-lexer beg end 1))
         (cur-buf (current-buffer))
         (first-token (cadr lexemes))
         (first-token-name (srefactor--lisp-token-text first-token))
         (second-token (caddr lexemes))
         (tmp-buf (generate-new-buffer (make-temp-name "")))
         (orig-format-type format-type)
         token-str
         ignore-pair
         ignore-num
         token)
    (unwind-protect
        (progn
          (unless (assoc 'semantic-list lexemes)
            (setq format-type 'one-line))
          (if (or (eq (car first-token) 'semantic-list)
                  (assoc first-token-name srefactor-lisp-symbol-to-skip))
              (setq newline-betwen-semantic-lists t))
          (setq ignore-pair (assoc first-token-name srefactor-lisp-symbol-to-skip))
          (setq ignore-num (cdr ignore-pair))
          (while lexemes
            (let* (token-type tok-start tok-end next-token next-token-start
                              next-token-type next-token-str)
              (srefactor--lisp-forward-token)
              (with-current-buffer tmp-buf
                (insert token-str)
                (srefactor--lisp-comment-formatter)
                (cond
                 ((and (eq token-type 'number)
                       (member next-token-str '("+" "-" "*" "/")))
                  (srefactor--lisp-number-formatter))
                 ((or (eq token-type 'punctuation)
                      (eq token-type 'open-paren)
                      (eq token-type 'close-paren)
                      (eq next-token-type 'close-paren))
                  (srefactor--lisp-punctuation-formatter))
                 ((eq token-type 'symbol)
                  (srefactor--lisp-symbol-formatter))
                 ((eq format-type 'one-line)
                  (srefactor--lisp-oneline-formatter))
                 ((eq format-type 'multi-line)
                  (srefactor--lisp-multiline-formatter))))))
          (kill-region beg end)
          (setq beg (point))
          (insert (with-current-buffer tmp-buf
                    (buffer-substring-no-properties (point-min)
                                                    (point-max))))
          (setq end (point))
          ;; descend into sub-sexpressions
          (setq lexemes (semantic-emacs-lisp-lexer beg end 1))
          (when recursive-p
            (srefactor--lisp-visit-semantic-list-lex (nreverse lexemes))))
      (kill-buffer tmp-buf))))

(defun srefactor--lisp-number-formatter ()
  "Make use of dynamic scope of its parent
function `srefactor--lisp-format-one-or-multi-lines'"
  (goto-char (semantic-lex-token-end token))
  (insert next-token-str)
  (srefactor--lisp-comment-formatter)
  (insert " ")
  (setq first-token (semantic-lex-token 'symbol
                                        (semantic-lex-token-start token)
                                        (1+ (semantic-lex-token-end token))))
  (setq first-token-name (concat token-str next-token-str))
  (setq second-token (cadr lexemes))
  (srefactor--lisp-forward-token))

(defun srefactor--lisp-punctuation-formatter ()
  "Make use of dynamic scope of its parent
function `srefactor--lisp-format-one-or-multi-lines'"
  (let ((orig-token token)
        token
        token-str)
    (while (srefactor--lisp-token-in-punctuation-p (srefactor--lisp-forward-token))
      (insert token-str)
      (srefactor--lisp-comment-formatter))
    (when (eq first-token-name (srefactor--lisp-token-text orig-token))
      (srefactor--lisp-forward-first-second-token))
    (when token
      (push token lexemes))))

(defun srefactor--lisp-symbol-formatter ()
  "Insert additional text based on symbol appearance. Make use of
dynamic scope of its parent function `srefactor--lisp-format-one-or-multi-lines'"
  (cond
   ((and (not (equal token-str first-token-name))
         (eq orig-format-type 'multi-line)
         (string-match ":.*" token-str))
    (insert " ")
    (srefactor--lisp-forward-token)
    (while (member token-type '(punctuation open-paren semantic-list))
      (insert token-str)
      (srefactor--lisp-forward-token))
    (insert token-str)
    (cond
     ((or (equal next-token-str "}"))
      (insert next-token-str "\n" " ")
      (srefactor--lisp-comment-formatter)
      (srefactor--lisp-forward-token))
     ((not (or (srefactor--lisp-token-in-punctuation-p next-token)
               (null next-token)))
      (insert "\n"))
     (t)))
   ((member token-str '("~@" "?")) "")
   ((string-equal token-str ".") (insert " "))
   ((eq format-type 'one-line)
    (srefactor--lisp-oneline-formatter))
   ((eq format-type 'multi-line)
    (srefactor--lisp-multiline-formatter))))

(defun srefactor--lisp-forward-first-second-token ()
  (setq first-token token)
  (setq first-token-name (srefactor--lisp-token-text first-token))
  (setq second-token (car lexemes)))

(defun srefactor--lisp-forward-token ()
  (setq token (pop lexemes))
  (when token
    (setq token-type (semantic-lex-token-class token))
    (setq tok-start (semantic-lex-token-start token))
    (setq tok-end (semantic-lex-token-end token))
    (setq token-str (srefactor--lisp-token-text token))
    (setq next-token (car lexemes))
    (setq next-token-type (semantic-lex-token-class next-token))
    (setq next-token-start (semantic-lex-token-start next-token))
    (setq next-token-end (semantic-lex-token-end next-token))
    (setq next-token-str (if next-token
                             (srefactor--lisp-token-text next-token)
                           ""))
    token))

(defun srefactor--lisp-comment-formatter ()
  (let (comment-token comment-token-start comment-token-end
                      comment-content next-token-real-line token-real-line
                      comment-real-line-start comment-real-line-end)
    (when (and tok-end next-token-start)
      (setq comment-token (with-current-buffer cur-buf ;; asdf
                            (condition-case nil
                                (car (semantic-comment-lexer tok-end next-token-start))
                              (error nil))))
      (when comment-token
        (setq comment-content (with-current-buffer cur-buf
                                ;; set values inside the buffer to avoid global variable
                                (setq comment-token-start (semantic-lex-token-start comment-token))
                                (setq comment-token-end (semantic-lex-token-end comment-token))
                                (setq comment-real-line-start (line-number-at-pos comment-token-start))
                                (setq comment-real-line-end (line-number-at-pos comment-token-end))
                                (setq token-real-line (line-number-at-pos tok-end))
                                (setq next-token-real-line (line-number-at-pos next-token-start))
                                (buffer-substring-no-properties comment-token-start
                                                                comment-token-end)))
        (cond
         ;; if comment token is next to a string, chances are it is below the
         ;; docstring. Add a newlien in between.
         ((eq token-type 'string)
          (insert "\n" comment-content))
         ((= token-real-line comment-real-line-start)
          (insert " " comment-content))
         ((not (= token-real-line comment-real-line-start))
          (insert "\n" comment-content))
         (t))
        ;; If the current/next token is a punctuation (open/close paren,
        ;; punctuation) add a newline no matter what; otherwise it destroys the
        ;; layout of sexp because nonewline is inserted after the current/next
        ;; token and it will be in the same line with the just inserted comment
        ;; and be part of it, which is dangerous
        (when (or (srefactor--lisp-token-in-punctuation-p token)
                  (srefactor--lisp-token-in-punctuation-p next-token)
                  (string-match "[]}]" token-str))
          (insert "\n"))))))

(defun srefactor--lisp-oneline-formatter ()
  (unless (srefactor--lisp-token-in-punctuation-p token)
    (let ((distance (- (point)
                       (line-beginning-position))))
      (if (or (eq orig-format-type 'one-line)
              (<= distance srefactor-newline-threshold))
          (insert " ")
        (insert "\n")))))

(defun srefactor--lisp-multiline-formatter ()
  (cond
   (ignore-num (when (and (equal first-token-name token-str))
                 (insert " ")
                 (when (and ignore-num
                            (= ignore-num 0))
                   (setq ignore-num (1- ignore-num))))
               (while (> ignore-num 0)
                 (if (srefactor--lisp-token-paren-p token)
                     (progn
                       (delete-char -1)
                       (push token lexemes)
                       (setq ignore-num 0))
                   (srefactor--lisp-forward-token)
                   (insert token-str)
                   (srefactor--lisp-comment-formatter)
                   (if (srefactor--lisp-token-in-punctuation-p token)
                       (srefactor--lisp-forward-first-second-token)
                     (setq ignore-num (1- ignore-num))
                     (insert " "))))
               (delete-char -1)
               (if (srefactor--lisp-token-paren-p (car lexemes))
                   (srefactor--lisp-punctuation-formatter)
                 (insert "\n"))
               (setq ignore-num nil))
   ((and (equal first-token-name token-str)
         (not (eq next-token-type 'semantic-list)))
    (insert " "))
   ((and (eq next-token-type 'semantic-list)
         (eq token-type 'symbol)
         (equal first-token-name token-str))
    (insert " "))
   ((eq token-type 'semantic-list)
    (insert "\n"))
   ((or (null ignore-num)
        (= ignore-num 0))
    (insert "\n"))
   (t (insert "\n"))))

(defun srefactor--lisp-token-name-in-skip-list-p (token-name)
  (member token-name srefactor-lisp-symbol-to-skip))

(defun srefactor--lisp-token-in-punctuation-p (token)
  (member (semantic-lex-token-class token) '(open-paren charquote close-paren punctuation)))

(defun srefactor--lisp-token-paren-p (token)
  (member (semantic-lex-token-class token) '(open-paren close-paren)))

(defun srefactor--lisp-token-text (token)
  (if token
      (with-current-buffer cur-buf
        (buffer-substring-no-properties (semantic-lex-token-start token)
                                        (semantic-lex-token-end token)))
    ""))

(defun srefactor--lisp-visit-semantic-list-lex (lexemes)
  "Visit and format all sub-sexpressions (semantic list) in LEXEMES."
  (dolist (token lexemes)
    (let ((tok-start (semantic-lex-token-start token))
          (tok-end (semantic-lex-token-end token))
          tok-str)
      (when (and (eq (car token) 'semantic-list)
                 (> (- tok-end tok-start) 2))
        (goto-char (semantic-lex-token-start token))
        (srefactor--lisp-format-one-or-multi-lines tok-start
                                                   tok-end
                                                   tok-start
                                                   format-type
                                                   (assoc tok-str srefactor-lisp-symbol-to-skip)
                                                   recursive-p)))))

(defun srefactor--lisp-comment-debug-messages ()
  (message "comment-token: %s" comment-token)
  (message "comment-start: %s" comment-token-start)
  (message "comment-end: %s" comment-token-end)
  (message "comment-content: %s" comment-content)
  (message "comment-content: %s" comment-content)
  (message "token-real-line: %s" token-real-line)
  (message "next-token-real-line: %s" next-token-real-line)
  (message "comment-real-line-start: %s" comment-real-line-start)
  (message "comment-real-line-end %s" comment-real-line-end))

(defun srefactor--lisp-debug-messages ()
  (message "token: %s" token)
  (message "token-type: %s" token-type)
  (message "token-str: %s" token-str)
  (when ignore-num
    (message "ignore-num: %s" ignore-num))
  (message "next-token: %s" next-token)
  (message "next-token-type: %s" next-token-type)
  (message "next-token-str: %s" next-token-str))

(provide 'srefactor-lisp)