* lisp/vc/smerge-mode.el: Resolve comment conflicts more aggressively.

(smerge-resolve--normalize-re): New var.
(smerge-resolve--extract-comment, smerge-resolve--normalize): New funs.
(smerge-resolve): Use them.
* lisp/newcomment.el (comment-only-p): New function.
(comment-or-uncomment-region): Use it.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 4ce53e701a7883a07dbb376c7a9f49a900b6c680..320335c4e7af122ef1b79d69523a6d9299d16599 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,12 @@
+2011-01-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+       * vc/smerge-mode.el: Resolve comment conflicts more aggressively.
+       (smerge-resolve--normalize-re): New var.
+       (smerge-resolve--extract-comment, smerge-resolve--normalize): New funs.
+       (smerge-resolve): Use them.
+       * newcomment.el (comment-only-p): New function.
+       (comment-or-uncomment-region): Use it.
+
 2011-01-14  Brent Goodrick  <bgoodr@gmail.com>  (tiny change)
 
        * abbrev.el (prepare-abbrev-list-buffer): If listing local abbrev

diff --git a/lisp/newcomment.el b/lisp/newcomment.el
index 0f7395132272aa9699ffd2e0fa505db27ca73e3a..6e2955c6607e389371556a1776f34bd375119edc 100644 (file)
--- a/lisp/newcomment.el
+++ b/lisp/newcomment.el
@@ -1185,6 +1185,12 @@ end- comment markers additionally to what `comment-add' already specifies."
                           'box-multi 'box)))
     (comment-region beg end (+ comment-add arg))))
 
+(defun comment-only-p (beg end)
+  "Return non-nil if the text between BEG and END is all comments."
+  (save-excursion
+    (goto-char beg)
+    (comment-forward (point-max))
+    (<= end (point))))
 
 ;;;###autoload
 (defun comment-or-uncomment-region (beg end &optional arg)
@@ -1193,10 +1199,7 @@ in which case call `uncomment-region'.  If a prefix arg is given, it
 is passed on to the respective function."
   (interactive "*r\nP")
   (comment-normalize-vars)
-  (funcall (if (save-excursion ;; check for already commented region
-                (goto-char beg)
-                (comment-forward (point-max))
-                (<= end (point)))
+  (funcall (if (comment-only-p beg end)
               'uncomment-region 'comment-region)
           beg end arg))
 

diff --git a/lisp/vc/smerge-mode.el b/lisp/vc/smerge-mode.el
index 296ae635d0b009064a2727ee7c9ad84c2cde7639..4b85a964fdd9dd532739a40aa6d48ba88a51f862 100644 (file)
--- a/lisp/vc/smerge-mode.el
+++ b/lisp/vc/smerge-mode.el
@@ -46,7 +46,7 @@
 
 (eval-when-compile (require 'cl))
 (require 'diff-mode)                    ;For diff-auto-refine-mode.
-
+(require 'newcomment)
 
 ;;; The real definition comes later.
 (defvar smerge-mode)
@@ -455,6 +455,37 @@ BUF contains a plain diff between match-1 and match-3."
               (insert ">>>>>>> " name3 "\n")
               (setq line endline))))))))
 
+(defconst smerge-resolve--normalize-re "[\n\t][ \t\n]*\\| [ \t\n]+")
+
+(defun smerge-resolve--extract-comment (beg end)
+  "Extract the text within the comments that span BEG..END."
+  (save-excursion
+    (let ((comments ())
+          combeg)
+      (goto-char beg)
+      (while (and (< (point) end)
+                  (setq combeg (comment-search-forward end t)))
+        (let ((beg (point)))
+          (goto-char combeg)
+          (comment-forward 1)
+          (save-excursion
+            (comment-enter-backward)
+            (push " " comments)
+            (push (buffer-substring-no-properties beg (point)) comments))))
+      (push " " comments)
+      (with-temp-buffer
+        (apply #'insert (nreverse comments))
+        (goto-char (point-min))
+        (while (re-search-forward smerge-resolve--normalize-re
+                                  nil t)
+          (replace-match " "))
+        (buffer-string)))))
+
+(defun smerge-resolve--normalize (beg end)
+  (replace-regexp-in-string
+   smerge-resolve--normalize-re " "
+   (concat " " (buffer-substring-no-properties beg end) " ")))
+
 (defun smerge-resolve (&optional safe)
   "Resolve the conflict at point intelligently.
 This relies on mode-specific knowledge and thus only works in some
@@ -472,7 +503,8 @@ major modes.  Uses `smerge-resolve-function' to do the actual work."
        (m2e (match-end 2))
        (m3e (match-end 3))
        (buf (generate-new-buffer " *smerge*"))
-        m b o)
+        m b o
+        choice)
     (unwind-protect
        (progn
           (cond
@@ -557,6 +589,43 @@ major modes.  Uses `smerge-resolve-function' to do the actual work."
              (narrow-to-region m0b m0e)
               (smerge-remove-props m0b m0e)
              (insert-file-contents m nil nil nil t)))
+           ;; If the conflict is only made of comments, and one of the two
+           ;; changes is only rearranging spaces (e.g. reflowing text) while
+           ;; the other is a real change, drop the space-rearrangement.
+           ((and m2e
+                 (comment-only-p m1b m1e)
+                 (comment-only-p m2b m2e)
+                 (comment-only-p m3b m3e)
+                 (let ((t1 (smerge-resolve--extract-comment m1b m1e))
+                       (t2 (smerge-resolve--extract-comment m2b m2e))
+                       (t3 (smerge-resolve--extract-comment m3b m3e)))
+                   (cond
+                    ((and (equal t1 t2) (not (equal t2 t3)))
+                     (setq choice 3))
+                    ((and (not (equal t1 t2)) (equal t2 t3))
+                     (setq choice 1)))))
+            (set-match-data md)
+           (smerge-keep-n choice))
+           ;; Idem, when the conflict is contained within a single comment.
+           ((save-excursion
+              (and m2e
+                   (nth 4 (syntax-ppss m0b))
+                   ;; If there's a conflict earlier in the file,
+                   ;; syntax-ppss is not reliable.
+                   (not (re-search-backward smerge-begin-re nil t))
+                   (progn (goto-char (nth 8 (syntax-ppss m0b)))
+                          (forward-comment 1)
+                          (> (point) m0e))
+                   (let ((t1 (smerge-resolve--normalize m1b m1e))
+                         (t2 (smerge-resolve--normalize m2b m2e))
+                         (t3 (smerge-resolve--normalize m3b m3e)))
+                     (cond
+                    ((and (equal t1 t2) (not (equal t2 t3)))
+                     (setq choice 3))
+                    ((and (not (equal t1 t2)) (equal t2 t3))
+                     (setq choice 1))))))
+            (set-match-data md)
+           (smerge-keep-n choice))
            (t
             (error "Don't know how to resolve"))))
       (if (buffer-name buf) (kill-buffer buf))