Use linewise paste only if register is missing no trailing newline

We use linewise paste if any of the pasted register elements has a trailing
newline.  As shown in the previous patch, this leads to awkward situations
where insertion positions from <a-P> are not monotonically increasing.

This complicated behavior is questionable.  The root cause is that linewise
paste may insert some strings that don't have a trailing newline.  This leads
to weird cases of GIGO, especially when using <a-P> when the last element
is missing a trailing newline.

Simplify the implementation by not activating linewise paste in that case.

Instead of special-casing the last element, try to simplify the behavior
further by using line-wise paste only if *all* elements are properly
terminated. I can't think of a real-world case where the existing behavior
would be desired.

A regression test shows a change in behavior. Might be less weird now.
The added test case is a copy except it uses "P" instead of "p" (the extra
newline is because "d" deletes the last newline in the buffer which gets
added back implicitly).

(I think the list of register elements is never empty, so this should never
cause a trivial linewise paste. Even if so, that would be fine because
inserting nothing is a nop either way.)

Fixes #5312

2 files changed, 13 insertions, 13 deletions

diff --git a/src/normal.cc b/src/normal.cc
index ba5b6e06..d2318865 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -716,7 +716,7 @@ void paste(Context& context, NormalParams params)
 {
     const char reg = params.reg ? params.reg : '"';
     auto strings = RegisterManager::instance()[reg].get(context);
-    const bool linewise = any_of(strings, [](StringView str) {
+    const bool linewise = all_of(strings, [](StringView str) {
         return not str.empty() and str.back() == '\n';
     });
 
@@ -741,7 +741,6 @@ void paste_all(Context& context, NormalParams params)
 {
     const char reg = params.reg ? params.reg : '"';
     auto strings = RegisterManager::instance()[reg].get(context);
-    bool linewise = false;
     String all;
     Vector<ByteCount> offsets;
     for (auto& str : strings)
@@ -749,11 +748,12 @@ void paste_all(Context& context, NormalParams params)
         if (str.empty())
             continue;
 
-        if (str.back() == '\n')
-            linewise = true;
         all += str;
         offsets.push_back(all.length());
     }
+    const bool linewise = all_of(strings, [](StringView str) {
+        return not str.empty() and str.back() == '\n';
+    });
 
     if (offsets.empty())
         throw runtime_error("nothing to paste");
diff --git a/src/selection.cc b/src/selection.cc
index f893f21f..99b21c3e 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -394,18 +394,18 @@ void SelectionList::for_each(ApplyFunc func, bool may_append)
     }
     else
     {
+        ForwardChangesTracker changes_tracker;
         for (size_t index = 0; index < m_selections.size(); ++index)
         {
-            ForwardChangesTracker changes_tracker;
-            func(index, m_selections[index]);
+            auto& sel = m_selections[index];
+
+            sel.anchor() = changes_tracker.get_new_coord_tolerant(sel.anchor());
+            sel.cursor() = changes_tracker.get_new_coord_tolerant(sel.cursor());
+            kak_assert(m_buffer->is_valid(sel.anchor()) and m_buffer->is_valid(sel.cursor()));
+
+            func(index, sel);
+
             changes_tracker.update(*m_buffer, m_timestamp);
-            for (size_t i = index + 1; i < m_selections.size(); ++i)
-            {
-                auto& sel = m_selections[i];
-                sel.anchor() = changes_tracker.get_new_coord_tolerant(sel.anchor());
-                sel.cursor() = changes_tracker.get_new_coord_tolerant(sel.cursor());
-                kak_assert(m_buffer->is_valid(sel.anchor()) and m_buffer->is_valid(sel.cursor()));
-            }
         }
     }