From a51027602544bb7d67a3313cca859bac897894b6 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 11 May 2014 12:20:59 +0100
Subject: [PATCH 01/53] Maintain an append-only list of changes in Buffer

---
 src/buffer.cc     | 34 +++++++++++++++++-----------------
 src/buffer.hh     | 12 +++++++++++-
 src/buffer.inl.hh |  8 +++++++-
 3 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index dbdd6247..5219f1b6 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -19,8 +19,6 @@ Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
       m_flags(flags | Flags::NoUndo),
       m_history(), m_history_cursor(m_history.begin()),
       m_last_save_undo_index(0),
-      // start buffer timestamp at 1 so that caches can init to 0
-      m_timestamp(1),
       m_fs_timestamp(fs_timestamp),
       m_hooks(GlobalHooks::instance()),
       m_options(GlobalOptions::instance()),
@@ -37,10 +35,12 @@ Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ m_timestamp, pos, std::move(line) });
+        m_lines.emplace_back(Line{ m_changes.size()+1, pos, std::move(line) });
         pos += m_lines.back().length();
     }
 
+    m_changes.push_back({ Change::Insert, {0,0}, line_count() });
+
     if (flags & Flags::File)
     {
         if (flags & Flags::New)
@@ -78,12 +78,13 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     for (auto listener : m_change_listeners)
         listener->on_erase(*this, {0,0}, back_coord());
 
+    m_changes.push_back({ Change::Erase, {0,0}, back_coord() });
+
     m_history.clear();
     m_current_undo_group.clear();
     m_history_cursor = m_history.begin();
     m_last_save_undo_index = 0;
     m_lines.clear();
-    ++m_timestamp;
 
     if (lines.empty())
         lines.emplace_back("\n");
@@ -93,11 +94,13 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ m_timestamp, pos, std::move(line) });
+        m_lines.emplace_back(Line{ m_changes.size()+1, pos, std::move(line) });
         pos += m_lines.back().length();
     }
     m_fs_timestamp = fs_timestamp;
 
+    m_changes.push_back({ Change::Insert, {0,0}, back_coord() });
+
     for (auto listener : m_change_listeners)
         listener->on_insert(*this, {0,0}, back_coord());
 }
@@ -448,7 +451,6 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
     if (content.empty())
         return pos;
 
-    ++m_timestamp;
     ByteCount offset = this->offset(pos);
 
     // all following lines advanced by length
@@ -466,12 +468,12 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
         {
             if (content[i] == '\n')
             {
-                m_lines.push_back({ m_timestamp, offset + start, content.substr(start, i + 1 - start) });
+                m_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start, i + 1 - start) });
                 start = i + 1;
             }
         }
         if (start != content.length())
-            m_lines.push_back({ m_timestamp, offset + start, content.substr(start) });
+            m_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start) });
 
         begin = pos.column == 0 ? pos : ByteCoord{ pos.line + 1, 0 };
         end = ByteCoord{ line_count()-1, m_lines.back().length() };
@@ -492,18 +494,18 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
                 if (start == 0)
                 {
                     line_content = prefix + line_content;
-                    new_lines.push_back({ m_timestamp, offset + start - prefix.length(),
+                    new_lines.push_back({ m_changes.size()+1, offset + start - prefix.length(),
                                           std::move(line_content) });
                 }
                 else
-                    new_lines.push_back({ m_timestamp, offset + start, std::move(line_content) });
+                    new_lines.push_back({ m_changes.size()+1, offset + start, std::move(line_content) });
                 start = i + 1;
             }
         }
         if (start == 0)
-            new_lines.push_back({ m_timestamp, offset + start - prefix.length(), prefix + content + suffix });
+            new_lines.push_back({ m_changes.size()+1, offset + start - prefix.length(), prefix + content + suffix });
         else if (start != content.length() or not suffix.empty())
-            new_lines.push_back({ m_timestamp, offset + start, content.substr(start) + suffix });
+            new_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start) + suffix });
 
         LineCount last_line = pos.line + new_lines.size() - 1;
 
@@ -517,6 +519,7 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
         end = ByteCoord{ last_line, m_lines[last_line].length() - suffix.length() };
     }
 
+    m_changes.push_back({ Change::Insert, begin, end });
     for (auto listener : m_change_listeners)
         listener->on_insert(*this, begin, end);
     return begin;
@@ -526,11 +529,10 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
 {
     kak_assert(is_valid(begin));
     kak_assert(is_valid(end));
-    ++m_timestamp;
     const ByteCount length = distance(begin, end);
     String prefix = m_lines[begin.line].content.substr(0, begin.column);
     String suffix = m_lines[end.line].content.substr(end.column);
-    Line new_line = { m_timestamp, m_lines[begin.line].start, prefix + suffix };
+    Line new_line = { m_changes.size()+1, m_lines[begin.line].start, prefix + suffix };
 
     ByteCoord next;
     if (new_line.length() != 0)
@@ -548,6 +550,7 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
     for (LineCount i = begin.line+1; i < line_count(); ++i)
         m_lines[i].start -= length;
 
+    m_changes.push_back({ Change::Erase, begin, end });
     for (auto listener : m_change_listeners)
         listener->on_erase(*this, begin, end);
     return next;
@@ -628,10 +631,7 @@ void Buffer::notify_saved()
     m_flags &= ~Flags::New;
     size_t history_cursor_index = m_history_cursor - m_history.begin();
     if (m_last_save_undo_index != history_cursor_index)
-    {
-        ++m_timestamp;
         m_last_save_undo_index = history_cursor_index;
-    }
     m_fs_timestamp = get_fs_timestamp(m_name);
 }
 
diff --git a/src/buffer.hh b/src/buffer.hh
index ff09528e..46b982a8 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -175,6 +175,15 @@ public:
     void reload(std::vector<String> lines, time_t fs_timestamp = InvalidTime);
 
     void check_invariant() const;
+
+    struct Change
+    {
+        enum Type { Insert, Erase };
+        Type type;
+        ByteCoord begin;
+        ByteCoord end;
+    };
+    memoryview<Change> changes_since(size_t timestamp) const;
 private:
 
     void on_option_changed(const Option& option) override;
@@ -215,7 +224,8 @@ private:
     void revert_modification(const Modification& modification);
 
     size_t m_last_save_undo_index;
-    size_t m_timestamp;
+
+    std::vector<Change> m_changes;
 
     time_t m_fs_timestamp;
 
diff --git a/src/buffer.inl.hh b/src/buffer.inl.hh
index 1920857d..9cfa2d0f 100644
--- a/src/buffer.inl.hh
+++ b/src/buffer.inl.hh
@@ -88,7 +88,13 @@ inline LineCount Buffer::line_count() const
 
 inline size_t Buffer::timestamp() const
 {
-    return m_timestamp;
+    return m_changes.size();
+}
+
+inline memoryview<Buffer::Change> Buffer::changes_since(size_t timestamp) const
+{
+    return { m_changes.data() + timestamp,
+             m_changes.data() + m_changes.size() };
 }
 
 inline size_t Buffer::line_timestamp(LineCount line) const

From ddd8f8d392ae059298ffa6175165f6e224a009f9 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 11 May 2014 13:20:13 +0100
Subject: [PATCH 02/53] LineChangeWatcher uses Buffer::changes_since rather
 than listening

---
 src/buffer.cc              | 12 ++++---
 src/buffer.hh              |  1 +
 src/line_change_watcher.cc | 69 ++++++++++++++++++++++++++------------
 src/line_change_watcher.hh | 23 ++++++-------
 src/word_db.cc             |  2 +-
 5 files changed, 66 insertions(+), 41 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index 5219f1b6..c92f09b1 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -39,7 +39,7 @@ Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
         pos += m_lines.back().length();
     }
 
-    m_changes.push_back({ Change::Insert, {0,0}, line_count() });
+    m_changes.push_back({ Change::Insert, {0,0}, line_count(), true });
 
     if (flags & Flags::File)
     {
@@ -78,7 +78,7 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     for (auto listener : m_change_listeners)
         listener->on_erase(*this, {0,0}, back_coord());
 
-    m_changes.push_back({ Change::Erase, {0,0}, back_coord() });
+    m_changes.push_back({ Change::Erase, {0,0}, back_coord(), true });
 
     m_history.clear();
     m_current_undo_group.clear();
@@ -99,7 +99,7 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     }
     m_fs_timestamp = fs_timestamp;
 
-    m_changes.push_back({ Change::Insert, {0,0}, back_coord() });
+    m_changes.push_back({ Change::Insert, {0,0}, back_coord(), true });
 
     for (auto listener : m_change_listeners)
         listener->on_insert(*this, {0,0}, back_coord());
@@ -459,6 +459,7 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
 
     ByteCoord begin;
     ByteCoord end;
+    bool at_end = false;
     // if we inserted at the end of the buffer, we have created a new
     // line without inserting a '\n'
     if (is_end(pos))
@@ -477,6 +478,7 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
 
         begin = pos.column == 0 ? pos : ByteCoord{ pos.line + 1, 0 };
         end = ByteCoord{ line_count()-1, m_lines.back().length() };
+        at_end = true;
     }
     else
     {
@@ -519,7 +521,7 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
         end = ByteCoord{ last_line, m_lines[last_line].length() - suffix.length() };
     }
 
-    m_changes.push_back({ Change::Insert, begin, end });
+    m_changes.push_back({ Change::Insert, begin, end, at_end });
     for (auto listener : m_change_listeners)
         listener->on_insert(*this, begin, end);
     return begin;
@@ -550,7 +552,7 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
     for (LineCount i = begin.line+1; i < line_count(); ++i)
         m_lines[i].start -= length;
 
-    m_changes.push_back({ Change::Erase, begin, end });
+    m_changes.push_back({ Change::Erase, begin, end, is_end(begin) });
     for (auto listener : m_change_listeners)
         listener->on_erase(*this, begin, end);
     return next;
diff --git a/src/buffer.hh b/src/buffer.hh
index 46b982a8..89684ce5 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -182,6 +182,7 @@ public:
         Type type;
         ByteCoord begin;
         ByteCoord end;
+        bool at_end;
     };
     memoryview<Change> changes_since(size_t timestamp) const;
 private:
diff --git a/src/line_change_watcher.cc b/src/line_change_watcher.cc
index 2e7ba879..c13a43b2 100644
--- a/src/line_change_watcher.cc
+++ b/src/line_change_watcher.cc
@@ -1,12 +1,57 @@
 #include "line_change_watcher.hh"
 
+#include "buffer.hh"
+
 namespace Kakoune
 {
 
+namespace
+{
+
+struct Change
+{
+    LineCount pos;
+    LineCount num;
+};
+
+std::vector<Change> compute_changes(const Buffer& buffer, size_t timestamp)
+{
+    std::vector<Change> res;
+    for (auto& change : buffer.changes_since(timestamp))
+    {
+        ByteCoord begin = change.begin;
+        ByteCoord end = change.end;
+        if (change.type == Buffer::Change::Insert)
+        {
+            if (change.at_end and begin != ByteCoord{0,0})
+            {
+                kak_assert(begin.column == 0);
+                --begin.line;
+            }
+            res.push_back({begin.line, end.line - begin.line});
+        }
+        else
+        {
+            if (change.at_end and begin != ByteCoord{0,0})
+            {
+                kak_assert(begin.column == 0);
+                --begin.line;
+            }
+            res.push_back({begin.line, begin.line - end.line});
+        }
+    }
+    return res;
+}
+
+}
+
+LineChangeWatcher::LineChangeWatcher(const Buffer& buffer)
+    : m_buffer(&buffer), m_timestamp(buffer.timestamp()) {}
+
 std::vector<LineModification> LineChangeWatcher::compute_modifications()
 {
     std::vector<LineModification> res;
-    for (auto& change : m_changes)
+    for (auto& change : compute_changes(*m_buffer, m_timestamp))
     {
         auto pos = std::upper_bound(res.begin(), res.end(), change.pos,
                                     [](const LineCount& l, const LineModification& c)
@@ -58,28 +103,8 @@ std::vector<LineModification> LineChangeWatcher::compute_modifications()
                 it->new_line -= num_removed;
         }
     }
-    m_changes.clear();
+    m_timestamp = m_buffer->timestamp();
     return res;
 }
 
-void LineChangeWatcher::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end)
-{
-    if (buffer.is_end(end))
-    {
-        kak_assert(begin.column == 0);
-        --begin.line;
-    }
-    m_changes.push_back({begin.line, end.line - begin.line});
-}
-
-void LineChangeWatcher::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end)
-{
-    if (begin.line == buffer.line_count())
-    {
-        kak_assert(begin.column == 0);
-        --begin.line;
-    }
-    m_changes.push_back({begin.line, begin.line - end.line});
-}
-
 }
diff --git a/src/line_change_watcher.hh b/src/line_change_watcher.hh
index ce7bedfa..d35167ca 100644
--- a/src/line_change_watcher.hh
+++ b/src/line_change_watcher.hh
@@ -1,11 +1,14 @@
 #ifndef line_change_watcher_hh_INCLUDED
 #define line_change_watcher_hh_INCLUDED
 
-#include "buffer.hh"
+#include "units.hh"
+#include "utils.hh"
 
 namespace Kakoune
 {
 
+class Buffer;
+
 struct LineModification
 {
     LineCount old_line; // line position in the old buffer
@@ -16,23 +19,17 @@ struct LineModification
     LineCount diff() const { return new_line - old_line + num_added - num_removed; }
 };
 
-class LineChangeWatcher : public BufferChangeListener_AutoRegister
+class LineChangeWatcher
 {
 public:
-    LineChangeWatcher (const Buffer& buffer)
-        : BufferChangeListener_AutoRegister(const_cast<Buffer&>(buffer)) {}
+    LineChangeWatcher (const Buffer& buffer);
 
     std::vector<LineModification> compute_modifications();
-private:
-    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end) override;
-    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end) override;
 
-    struct Change
-    {
-        LineCount pos;
-        LineCount num;
-    };
-    std::vector<Change> m_changes;
+    const Buffer& buffer() const { return *m_buffer; }
+private:
+    safe_ptr<const Buffer> m_buffer;
+    size_t m_timestamp;
 };
 
 }
diff --git a/src/word_db.cc b/src/word_db.cc
index 62e19290..73f6e1ad 100644
--- a/src/word_db.cc
+++ b/src/word_db.cc
@@ -65,7 +65,7 @@ void WordDB::update_db()
     if (modifs.empty())
         return;
 
-    auto& buffer = m_change_watcher.registry();
+    auto& buffer = m_change_watcher.buffer();
 
     LineToWords new_lines;
     new_lines.reserve((int)buffer.line_count());

From 67a251ffd560d79e8337fef0aee8d8285d34355e Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 12 May 2014 13:59:21 +0100
Subject: [PATCH 03/53] Pass a at_end param to
 BufferChangeListener::on_{insert,erase}

---
 src/buffer.cc                 |  8 +++----
 src/buffer.hh                 |  4 ++--
 src/dynamic_selection_list.cc |  8 +++----
 src/dynamic_selection_list.hh |  4 ++--
 src/normal.cc                 |  8 +++----
 src/selection.cc              | 40 ++++++++++++++++++++---------------
 src/selection.hh              |  4 ++--
 7 files changed, 41 insertions(+), 35 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index c92f09b1..f4b6782f 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -76,7 +76,7 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     // use back coord to simulate the persistance of the last end of line
     // as buffers are expected to never be empty.
     for (auto listener : m_change_listeners)
-        listener->on_erase(*this, {0,0}, back_coord());
+        listener->on_erase(*this, {0,0}, back_coord(), true);
 
     m_changes.push_back({ Change::Erase, {0,0}, back_coord(), true });
 
@@ -102,7 +102,7 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     m_changes.push_back({ Change::Insert, {0,0}, back_coord(), true });
 
     for (auto listener : m_change_listeners)
-        listener->on_insert(*this, {0,0}, back_coord());
+        listener->on_insert(*this, {0,0}, back_coord(), true);
 }
 
 String Buffer::display_name() const
@@ -523,7 +523,7 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
 
     m_changes.push_back({ Change::Insert, begin, end, at_end });
     for (auto listener : m_change_listeners)
-        listener->on_insert(*this, begin, end);
+        listener->on_insert(*this, begin, end, at_end);
     return begin;
 }
 
@@ -554,7 +554,7 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
 
     m_changes.push_back({ Change::Erase, begin, end, is_end(begin) });
     for (auto listener : m_change_listeners)
-        listener->on_erase(*this, begin, end);
+        listener->on_erase(*this, begin, end, is_end(begin));
     return next;
 }
 
diff --git a/src/buffer.hh b/src/buffer.hh
index 89684ce5..f817eef0 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -67,9 +67,9 @@ class BufferChangeListener
 {
 public:
     virtual void on_insert(const Buffer& buffer,
-                           ByteCoord begin, ByteCoord end) = 0;
+                           ByteCoord begin, ByteCoord end, bool at_end) = 0;
     virtual void on_erase(const Buffer& buffer,
-                          ByteCoord begin, ByteCoord end) = 0;
+                          ByteCoord begin, ByteCoord end, bool at_end) = 0;
 };
 
 // A Buffer is a in-memory representation of a file
diff --git a/src/dynamic_selection_list.cc b/src/dynamic_selection_list.cc
index 569d7818..2792da30 100644
--- a/src/dynamic_selection_list.cc
+++ b/src/dynamic_selection_list.cc
@@ -36,14 +36,14 @@ void DynamicSelectionList::check_invariant() const
 #endif
 }
 
-void DynamicSelectionList::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+void DynamicSelectionList::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    update_insert(buffer, begin, end);
+    update_insert(begin, end, at_end);
 }
 
-void DynamicSelectionList::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+void DynamicSelectionList::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    update_erase(buffer, begin, end);
+    update_erase(begin, end, at_end);
 }
 
 }
diff --git a/src/dynamic_selection_list.hh b/src/dynamic_selection_list.hh
index 4bfbd39a..2f408907 100644
--- a/src/dynamic_selection_list.hh
+++ b/src/dynamic_selection_list.hh
@@ -19,8 +19,8 @@ public:
     void check_invariant() const;
 
 private:
-    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end) override;
-    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end) override;
+    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end) override;
+    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end) override;
 };
 
 }
diff --git a/src/normal.cc b/src/normal.cc
index 062f512c..5016ece9 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1239,18 +1239,18 @@ public:
     ModifiedRangesListener(Buffer& buffer)
         : BufferChangeListener_AutoRegister(buffer) {}
 
-    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
     {
-        m_ranges.update_insert(buffer, begin, end);
+        m_ranges.update_insert(begin, end, at_end);
         auto it = std::upper_bound(m_ranges.begin(), m_ranges.end(), begin,
                                    [](ByteCoord c, const Selection& sel)
                                    { return c < sel.min(); });
         m_ranges.insert(it, Selection{ begin, buffer.char_prev(end) });
     }
 
-    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
     {
-        m_ranges.update_erase(buffer, begin, end);
+        m_ranges.update_erase(begin, end, at_end);
         auto pos = std::min(begin, buffer.back_coord());
         auto it = std::upper_bound(m_ranges.begin(), m_ranges.end(), pos,
                                    [](ByteCoord c, const Selection& sel)
diff --git a/src/selection.cc b/src/selection.cc
index e1627a0c..0049689d 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -18,8 +18,8 @@ namespace
 {
 
 template<template <bool, bool> class UpdateFunc>
-void on_buffer_change(const Buffer& buffer, SelectionList& sels,
-                      ByteCoord begin, ByteCoord end, LineCount end_line)
+void on_buffer_change(SelectionList& sels,
+                      ByteCoord begin, ByteCoord end, bool at_end, LineCount end_line)
 {
     auto update_beg = std::lower_bound(sels.begin(), sels.end(), begin,
                                        [](const Selection& s, ByteCoord c)
@@ -31,20 +31,20 @@ void on_buffer_change(const Buffer& buffer, SelectionList& sels,
     if (update_beg != update_only_line_beg)
     {
         // for the first one, we are not sure if min < begin
-        UpdateFunc<false, false>{}(buffer, update_beg->anchor(), begin, end);
-        UpdateFunc<false, false>{}(buffer, update_beg->cursor(), begin, end);
+        UpdateFunc<false, false>{}(update_beg->anchor(), begin, end, at_end);
+        UpdateFunc<false, false>{}(update_beg->cursor(), begin, end, at_end);
     }
     for (auto it = update_beg+1; it < update_only_line_beg; ++it)
     {
-        UpdateFunc<false, true>{}(buffer, it->anchor(), begin, end);
-        UpdateFunc<false, true>{}(buffer, it->cursor(), begin, end);
+        UpdateFunc<false, true>{}(it->anchor(), begin, end, at_end);
+        UpdateFunc<false, true>{}(it->cursor(), begin, end, at_end);
     }
     if (end.line > begin.line)
     {
         for (auto it = update_only_line_beg; it != sels.end(); ++it)
         {
-            UpdateFunc<true, true>{}(buffer, it->anchor(), begin, end);
-            UpdateFunc<true, true>{}(buffer, it->cursor(), begin, end);
+            UpdateFunc<true, true>{}(it->anchor(), begin, end, at_end);
+            UpdateFunc<true, true>{}(it->cursor(), begin, end, at_end);
         }
     }
 }
@@ -52,8 +52,8 @@ void on_buffer_change(const Buffer& buffer, SelectionList& sels,
 template<bool assume_different_line, bool assume_greater_than_begin>
 struct UpdateInsert
 {
-    void operator()(const Buffer& buffer, ByteCoord& coord,
-                    ByteCoord begin, ByteCoord end) const
+    void operator()(ByteCoord& coord, ByteCoord begin, ByteCoord end,
+                    bool at_end) const
     {
         if (assume_different_line)
             kak_assert(begin.line < coord.line);
@@ -69,15 +69,21 @@ struct UpdateInsert
 template<bool assume_different_line, bool assume_greater_than_begin>
 struct UpdateErase
 {
-    void operator()(const Buffer& buffer, ByteCoord& coord,
-                    ByteCoord begin, ByteCoord end) const
+    void operator()(ByteCoord& coord, ByteCoord begin, ByteCoord end,
+                    bool at_end) const
     {
         if (not assume_greater_than_begin and coord < begin)
             return;
         if (assume_different_line)
             kak_assert(end.line < coord.line);
         if (not assume_different_line and coord <= end)
-            coord = buffer.clamp(begin);
+        {
+            if (not at_end)
+                coord = begin;
+            else
+                coord = begin.column ? ByteCoord{begin.line, begin.column-1}
+                                     : ByteCoord{begin.line - 1};
+        }
         else
         {
             if (not assume_different_line and end.line == coord.line)
@@ -93,14 +99,14 @@ struct UpdateErase
 
 }
 
-void SelectionList::update_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+void SelectionList::update_insert(ByteCoord begin, ByteCoord end, bool at_end)
 {
-    on_buffer_change<UpdateInsert>(buffer, *this, begin, end, begin.line);
+    on_buffer_change<UpdateInsert>(*this, begin, end, at_end, begin.line);
 }
 
-void SelectionList::update_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end)
+void SelectionList::update_erase(ByteCoord begin, ByteCoord end, bool at_end)
 {
-    on_buffer_change<UpdateErase>(buffer, *this, begin, end, end.line);
+    on_buffer_change<UpdateErase>(*this, begin, end, at_end, end.line);
 }
 
 void SelectionList::check_invariant() const
diff --git a/src/selection.hh b/src/selection.hh
index 61e1cc54..016ce5f5 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -61,8 +61,8 @@ struct SelectionList
     SelectionList(ByteCoord c) : m_selections{Selection{c,c}} {}
     SelectionList(Selection s) : m_selections{s} {}
 
-    void update_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end);
-    void update_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end);
+    void update_insert(ByteCoord begin, ByteCoord end, bool at_end);
+    void update_erase(ByteCoord begin, ByteCoord end, bool at_end);
 
     void check_invariant() const;
 

From 8ab1f58594e35c268d6749af835f439ff714af1a Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 12 May 2014 19:10:25 +0100
Subject: [PATCH 04/53] Use a Buffer::changes_since based implementation for
 undo/redo

---
 src/normal.cc | 96 +++++++++++++++++++++++++++++----------------------
 1 file changed, 54 insertions(+), 42 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index 5016ece9..45642b22 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1233,52 +1233,63 @@ void spaces_to_tabs(Context& context, int ts)
     }
 }
 
-class ModifiedRangesListener : public BufferChangeListener_AutoRegister
+static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timestamp)
 {
-public:
-    ModifiedRangesListener(Buffer& buffer)
-        : BufferChangeListener_AutoRegister(buffer) {}
-
-    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
+    SelectionList ranges;
+    for (auto& change : buffer.changes_since(timestamp))
     {
-        m_ranges.update_insert(begin, end, at_end);
-        auto it = std::upper_bound(m_ranges.begin(), m_ranges.end(), begin,
-                                   [](ByteCoord c, const Selection& sel)
-                                   { return c < sel.min(); });
-        m_ranges.insert(it, Selection{ begin, buffer.char_prev(end) });
+        const ByteCoord& begin = change.begin;
+        const ByteCoord& end = change.end;
+        if (change.type == Buffer::Change::Insert)
+        {
+            ranges.update_insert(begin, end, change.at_end);
+            auto it = std::upper_bound(ranges.begin(), ranges.end(), begin,
+                                       [](ByteCoord c, const Selection& sel)
+                                       { return c < sel.min(); });
+            ranges.insert(it, Selection{begin, end});
+        }
+        else
+        {
+            ranges.update_erase(begin, end, change.at_end);
+            auto pos = begin;
+            if (change.at_end)
+                pos = begin.column ? ByteCoord{begin.line, begin.column - 1}
+                                   : ByteCoord{begin.line - 1};
+            auto it = std::upper_bound(ranges.begin(), ranges.end(), pos,
+                                       [](ByteCoord c, const Selection& sel)
+                                       { return c < sel.min(); });
+            ranges.insert(it, Selection{pos, pos});
+        }
     }
+    if (ranges.empty())
+        return ranges;
 
-    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
+    ranges.set_main_index(ranges.size() - 1);
+
+    auto touches = [&](const Selection& lhs, const Selection& rhs) {
+        return lhs.min() <= rhs.min() ? buffer.char_next(lhs.max()) >= rhs.min()
+                                      : lhs.min() <= buffer.char_next(rhs.max());
+    };
+    ranges.merge_overlapping(touches);
+
+    for (auto& sel : ranges)
     {
-        m_ranges.update_erase(begin, end, at_end);
-        auto pos = std::min(begin, buffer.back_coord());
-        auto it = std::upper_bound(m_ranges.begin(), m_ranges.end(), pos,
-                                   [](ByteCoord c, const Selection& sel)
-                                   { return c < sel.min(); });
-        m_ranges.insert(it, Selection{ pos, pos });
+        if (sel.anchor() != sel.cursor())
+            sel.cursor() = buffer.char_prev(sel.cursor());
     }
-    SelectionList& ranges() { return m_ranges; }
-
-private:
-    SelectionList m_ranges;
-};
-
-inline bool touches(const Buffer& buffer, const Selection& lhs, const Selection& rhs)
-{
-    return lhs.min() <= rhs.min() ? buffer.char_next(lhs.max()) >= rhs.min()
-                                  : lhs.min() <= buffer.char_next(rhs.max());
+    return ranges;
 }
 
 void undo(Context& context, int)
 {
-    ModifiedRangesListener listener(context.buffer());
-    bool res = context.buffer().undo();
-    if (res and not listener.ranges().empty())
+    Buffer& buffer = context.buffer();
+    size_t timestamp = buffer.timestamp();
+    bool res = buffer.undo();
+    if (res)
     {
-        auto& selections = context.selections();
-        selections = std::move(listener.ranges());
-        selections.set_main_index(selections.size() - 1);
-        selections.merge_overlapping(std::bind(touches, std::ref(context.buffer()), _1, _2));
+        auto ranges = compute_modified_ranges(buffer, timestamp);
+        if (not ranges.empty())
+            context.selections() = std::move(ranges);
     }
     else if (not res)
         context.print_status({ "nothing left to undo", get_color("Information") });
@@ -1287,15 +1298,16 @@ void undo(Context& context, int)
 void redo(Context& context, int)
 {
     using namespace std::placeholders;
-    ModifiedRangesListener listener(context.buffer());
-    bool res = context.buffer().redo();
-    if (res and not listener.ranges().empty())
+    Buffer& buffer = context.buffer();
+    size_t timestamp = buffer.timestamp();
+    bool res = buffer.redo();
+    if (res)
     {
-        auto& selections = context.selections();
-        selections = std::move(listener.ranges());
-        selections.set_main_index(selections.size() - 1);
-        selections.merge_overlapping(std::bind(touches, std::ref(context.buffer()), _1, _2));
+        auto ranges = compute_modified_ranges(buffer, timestamp);
+        if (not ranges.empty())
+            context.selections() = std::move(ranges);
     }
+
     else if (not res)
         context.print_status({ "nothing left to redo", get_color("Information") });
 }

From 7bc73b7ef9402f81a6bb496b03ba84197f76e642 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Tue, 13 May 2014 18:59:22 +0100
Subject: [PATCH 05/53] negative coordinates are invalid

---
 src/buffer.inl.hh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/buffer.inl.hh b/src/buffer.inl.hh
index 9cfa2d0f..5375d993 100644
--- a/src/buffer.inl.hh
+++ b/src/buffer.inl.hh
@@ -52,6 +52,9 @@ inline ByteCount Buffer::offset(ByteCoord c) const
 
 inline bool Buffer::is_valid(ByteCoord c) const
 {
+    if (c.line < 0 or c.column < 0)
+        return false;
+
     return (c.line < line_count() and c.column < m_lines[c.line].length()) or
            (c.line == line_count() - 1 and c.column == m_lines.back().length()) or
            (c.line == line_count() and c.column == 0);

From ea3e92aa5e68e73fa95196332b739891bbf3f24f Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 12 May 2014 23:25:15 +0100
Subject: [PATCH 06/53] SelectionList know its buffer and timestamp

---
 src/buffer.cc                 |  2 +-
 src/client.cc                 |  4 +-
 src/client_manager.cc         |  6 +--
 src/client_manager.hh         |  3 +-
 src/commands.cc               | 16 +++++---
 src/context.cc                | 10 ++---
 src/context.hh                |  3 +-
 src/dynamic_selection_list.cc | 25 ++----------
 src/dynamic_selection_list.hh |  5 ++-
 src/input_handler.cc          |  4 +-
 src/input_handler.hh          |  2 +-
 src/normal.cc                 | 28 ++++++++------
 src/selection.cc              | 71 ++++++++++++++++++++++++++++++++++-
 src/selection.hh              | 40 +++++++++-----------
 src/selectors.cc              |  6 +--
 src/selectors.hh              |  4 +-
 src/window.cc                 |  8 ++--
 17 files changed, 150 insertions(+), 87 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index f4b6782f..4e7c2606 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -706,7 +706,7 @@ void Buffer::on_option_changed(const Option& option)
 
 void Buffer::run_hook_in_own_context(const String& hook_name, const String& param)
 {
-    InputHandler hook_handler(*this, { Selection{} });
+    InputHandler hook_handler({ *this, Selection{} });
     m_hooks.run_hook(hook_name, param, hook_handler.context());
 }
 
diff --git a/src/client.cc b/src/client.cc
index 5be59b99..dacaf607 100644
--- a/src/client.cc
+++ b/src/client.cc
@@ -18,7 +18,7 @@ Client::Client(std::unique_ptr<UserInterface>&& ui,
                EnvVarMap env_vars,
                String name)
     : m_ui{std::move(ui)}, m_window{std::move(window)},
-      m_input_handler{m_window->buffer(), std::move(selections),
+      m_input_handler{std::move(selections),
                       std::move(name)},
       m_env_vars(env_vars)
 {
@@ -102,7 +102,7 @@ static void reload_buffer(Context& context, const String& filename)
     if (not buf)
         return;
     context.change_buffer(*buf);
-    context.selections() = SelectionList{buf->clamp(cursor_pos)};
+    context.selections() = SelectionList{ *buf, buf->clamp(cursor_pos)};
     context.window().set_position(view_pos);
     context.print_status({ "'" + buf->display_name() + "' reloaded",
                            get_color("Information") });
diff --git a/src/client_manager.cc b/src/client_manager.cc
index 6e3fd638..692a1a46 100644
--- a/src/client_manager.cc
+++ b/src/client_manager.cc
@@ -94,18 +94,18 @@ WindowAndSelections ClientManager::get_free_window(Buffer& buffer)
             w->forget_timestamp();
             WindowAndSelections res = std::move(*it);
             m_free_windows.erase(it.base()-1);
+            res.selections.update();
             return res;
         }
     }
     return WindowAndSelections{ std::unique_ptr<Window>{new Window{buffer}},
-                                DynamicSelectionList{buffer,
-                                { Selection{ {}, {} } } } };
+                                SelectionList{ buffer, Selection{} } };
 }
 
 void ClientManager::add_free_window(std::unique_ptr<Window>&& window, SelectionList selections)
 {
     Buffer& buffer = window->buffer();
-    m_free_windows.push_back({ std::move(window), DynamicSelectionList{ buffer, std::move(selections) } });
+    m_free_windows.push_back({ std::move(window), SelectionList{ std::move(selections) }, buffer.timestamp() });
 }
 
 void ClientManager::ensure_no_client_uses_buffer(Buffer& buffer)
diff --git a/src/client_manager.hh b/src/client_manager.hh
index d3334486..410adab5 100644
--- a/src/client_manager.hh
+++ b/src/client_manager.hh
@@ -12,7 +12,8 @@ struct client_removed{};
 struct WindowAndSelections
 {
     std::unique_ptr<Window> window;
-    DynamicSelectionList selections;
+    SelectionList selections;
+    size_t timestamp;
 };
 
 class ClientManager : public Singleton<ClientManager>
diff --git a/src/commands.cc b/src/commands.cc
index e3437dfa..4629c3d1 100644
--- a/src/commands.cc
+++ b/src/commands.cc
@@ -131,7 +131,8 @@ void edit(const ParametersParser& parser, Context& context)
         int column = param_count > 2 and not parser[2].empty() ?
                      std::max(0, str_to_int(parser[2]) - 1) : 0;
 
-        context.selections() = context.buffer().clamp({ line,  column });
+        auto& buffer = context.buffer();
+        context.selections() = { buffer, buffer.clamp({ line,  column }) };
         if (context.has_window())
             context.window().center_line(context.selections().main().cursor().line);
     }
@@ -962,7 +963,7 @@ void context_wrap(const ParametersParser& parser, Context& context, Func func)
         for (auto& name : names)
         {
             Buffer& buffer = BufferManager::instance().get_buffer(name);
-            InputHandler input_handler{buffer, ( Selection{} )};
+            InputHandler input_handler{{ buffer, Selection{} }};
             func(parser, input_handler.context());
         }
         return;
@@ -980,7 +981,7 @@ void context_wrap(const ParametersParser& parser, Context& context, Func func)
 
     if (parser.has_option("draft"))
     {
-        InputHandler input_handler(real_context->buffer(), real_context->selections(), real_context->name());
+        InputHandler input_handler(real_context->selections(), real_context->name());
 
         // We do not want this draft context to commit undo groups if the real one is
         // going to commit the whole thing later
@@ -989,12 +990,17 @@ void context_wrap(const ParametersParser& parser, Context& context, Func func)
 
         if (parser.has_option("itersel"))
         {
-            DynamicSelectionList sels{real_context->buffer(), real_context->selections()};
+            SelectionList sels{real_context->selections()};
             ScopedEdition edition{input_handler.context()};
             for (auto& sel : sels)
             {
-                input_handler.context().selections() = sel;
+                input_handler.context().selections() = SelectionList{ sels.buffer(), sel, sels.timestamp() };
+                input_handler.context().selections().update();
+
                 func(parser, input_handler.context());
+
+                if (&sels.buffer() != &input_handler.context().buffer())
+                    throw runtime_error("the buffer has changed while iterating on selections");
             }
         }
         else
diff --git a/src/context.cc b/src/context.cc
index 00e3ff50..dac65284 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -10,10 +10,10 @@ namespace Kakoune
 Context::Context() = default;
 Context::~Context() = default;
 
-Context::Context(InputHandler& input_handler, Buffer& buffer,
-                 SelectionList selections, String name)
+Context::Context(InputHandler& input_handler, SelectionList selections,
+                 String name)
     : m_input_handler{&input_handler},
-      m_selections{{buffer, std::move(selections)}},
+      m_selections{std::move(selections)},
       m_name(std::move(name))
 {}
 
@@ -110,7 +110,7 @@ void Context::push_jump()
     }
     m_jump_list.erase(std::remove(begin(m_jump_list), end(m_jump_list), jump),
                       end(m_jump_list));
-    m_jump_list.push_back({buffer(), jump});
+    m_jump_list.push_back(jump);
     m_current_jump = m_jump_list.end();
 }
 
@@ -168,7 +168,7 @@ void Context::change_buffer(Buffer& buffer)
     if (has_client())
         client().change_buffer(buffer);
     else
-        m_selections = DynamicSelectionList{ buffer };
+        m_selections = DynamicSelectionList{ { buffer, Selection{} } };
     if (has_input_handler())
         input_handler().reset_normal_mode();
 }
diff --git a/src/context.hh b/src/context.hh
index 60264aba..f612e36a 100644
--- a/src/context.hh
+++ b/src/context.hh
@@ -26,7 +26,8 @@ class Context
 {
 public:
     Context();
-    Context(InputHandler& input_handler, Buffer& buffer, SelectionList selections, String name = "");
+    Context(InputHandler& input_handler, SelectionList selections,
+            String name = "");
     ~Context();
 
     Context(const Context&) = delete;
diff --git a/src/dynamic_selection_list.cc b/src/dynamic_selection_list.cc
index 2792da30..4087bb0c 100644
--- a/src/dynamic_selection_list.cc
+++ b/src/dynamic_selection_list.cc
@@ -3,10 +3,9 @@
 namespace Kakoune
 {
 
-DynamicSelectionList::DynamicSelectionList(Buffer& buffer,
-                                           SelectionList selections)
+DynamicSelectionList::DynamicSelectionList(SelectionList selections)
     : SelectionList(std::move(selections)),
-      BufferChangeListener_AutoRegister(buffer)
+      BufferChangeListener_AutoRegister(const_cast<Buffer&>(buffer()))
 {
     check_invariant();
 }
@@ -18,32 +17,16 @@ DynamicSelectionList& DynamicSelectionList::operator=(SelectionList selections)
     return *this;
 }
 
-void DynamicSelectionList::check_invariant() const
-{
-#ifdef KAK_DEBUG
-    SelectionList::check_invariant();
-    const Buffer& buffer = registry();
-    for (size_t i = 0; i < size(); ++i)
-    {
-        auto& sel = (*this)[i];
-        kak_assert(buffer.is_valid(sel.anchor()));
-        kak_assert(buffer.is_valid(sel.cursor()));
-        kak_assert(not buffer.is_end(sel.anchor()));
-        kak_assert(not buffer.is_end(sel.cursor()));
-        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.anchor())));
-        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.cursor())));
-    }
-#endif
-}
-
 void DynamicSelectionList::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
     update_insert(begin, end, at_end);
+    set_timestamp(buffer.timestamp());
 }
 
 void DynamicSelectionList::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
     update_erase(begin, end, at_end);
+    set_timestamp(buffer.timestamp());
 }
 
 }
diff --git a/src/dynamic_selection_list.hh b/src/dynamic_selection_list.hh
index 2f408907..65f37915 100644
--- a/src/dynamic_selection_list.hh
+++ b/src/dynamic_selection_list.hh
@@ -13,10 +13,11 @@ public:
     using iterator = SelectionList::iterator;
     using const_iterator = SelectionList::const_iterator;
 
-    DynamicSelectionList(Buffer& buffer, SelectionList selections = { Selection{} });
+    DynamicSelectionList(SelectionList selections);
 
     DynamicSelectionList& operator=(SelectionList selections);
-    void check_invariant() const;
+
+    using SelectionList::buffer;
 
 private:
     void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end) override;
diff --git a/src/input_handler.cc b/src/input_handler.cc
index f12a8854..62e3068f 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -875,9 +875,9 @@ void InputMode::reset_normal_mode()
     m_input_handler.reset_normal_mode();
 }
 
-InputHandler::InputHandler(Buffer& buffer, SelectionList selections, String name)
+InputHandler::InputHandler(SelectionList selections, String name)
     : m_mode(new InputModes::Normal(*this)),
-      m_context(*this, buffer, std::move(selections), std::move(name))
+      m_context(*this, std::move(selections), std::move(name))
 {
 }
 
diff --git a/src/input_handler.hh b/src/input_handler.hh
index 0d9d34cc..80b8b43c 100644
--- a/src/input_handler.hh
+++ b/src/input_handler.hh
@@ -35,7 +35,7 @@ enum class InsertMode : unsigned;
 class InputHandler : public SafeCountable
 {
 public:
-    InputHandler(Buffer& buffer, SelectionList selections, String name = "");
+    InputHandler(SelectionList selections, String name = "");
     ~InputHandler();
 
     // switch to insert mode
diff --git a/src/normal.cc b/src/normal.cc
index 45642b22..7ac51ad5 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -26,6 +26,7 @@ void erase(Buffer& buffer, SelectionList& selections)
     for (auto& sel : selections)
     {
         erase(buffer, sel);
+        selections.update();
         avoid_eol(buffer, sel);
     }
     selections.check_invariant();
@@ -178,7 +179,7 @@ void select_coord(const Buffer& buffer, ByteCoord coord, SelectionList& selectio
 {
     coord = buffer.clamp(coord);
     if (mode == SelectMode::Replace)
-        selections = SelectionList { coord };
+        selections = SelectionList{ buffer, coord };
     else if (mode == SelectMode::Extend)
     {
         for (auto& sel : selections)
@@ -598,7 +599,7 @@ void paste(Context& context, int)
 template<typename T>
 void regex_prompt(Context& context, const String prompt, T func)
 {
-    DynamicSelectionList selections{context.buffer(), context.selections()};
+    DynamicSelectionList selections{context.selections()};
     context.input_handler().prompt(prompt, "", get_color("Prompt"), complete_nothing,
         [=](const String& str, PromptEvent event, Context& context) {
             try
@@ -738,7 +739,7 @@ void split_lines(Context& context, int)
 {
     auto& selections = context.selections();
     auto& buffer = context.buffer();
-    SelectionList res;
+    SelectionList res(context.buffer());
     for (auto& sel : selections)
     {
         if (sel.anchor().line == sel.cursor().line)
@@ -760,7 +761,7 @@ void split_lines(Context& context, int)
 void join_select_spaces(Context& context, int)
 {
     auto& buffer = context.buffer();
-    SelectionList selections;
+    SelectionList selections(buffer);
     for (auto& sel : context.selections())
     {
         for (LineCount line = sel.min().line; line <= sel.max().line; ++line)
@@ -783,8 +784,12 @@ void join_select_spaces(Context& context, int)
 
 void join(Context& context, int param)
 {
-    DynamicSelectionList sels{context.buffer(), context.selections()};
-    auto restore_sels = on_scope_end([&]{ context.selections() = std::move(sels); });
+    SelectionList sels{context.selections()};
+    auto restore_sels = on_scope_end([&]{
+        sels.update();
+        context.selections() = std::move(sels);
+    });
+
     join_select_spaces(context, param);
 }
 
@@ -796,7 +801,7 @@ void keep(Context& context, int)
         if (ex.empty())
             return;
         const Buffer& buffer = context.buffer();
-        SelectionList keep;
+        SelectionList keep(buffer);
         for (auto& sel : context.selections())
         {
             if (boost::regex_search(buffer.iterator_at(sel.min()),
@@ -818,7 +823,7 @@ void keep_pipe(Context& context, int)
                 return;
             const Buffer& buffer = context.buffer();
             auto& shell_manager = ShellManager::instance();
-            SelectionList keep;
+            SelectionList keep(buffer);
             for (auto& sel : context.selections())
             {
                 int status = 0;
@@ -839,7 +844,7 @@ void indent(Context& context, int)
     String indent = indent_width == 0 ? "\t" : String{' ', indent_width};
 
     auto& buffer = context.buffer();
-    SelectionList sels;
+    SelectionList sels(buffer);
     for (auto& sel : context.selections())
     {
         for (auto line = sel.min().line; line < sel.max().line+1; ++line)
@@ -864,7 +869,7 @@ void deindent(Context& context, int)
         indent_width = tabstop;
 
     auto& buffer = context.buffer();
-    SelectionList sels;
+    SelectionList sels(buffer);
     for (auto& sel : context.selections())
     {
         for (auto line = sel.min().line; line < sel.max().line+1; ++line)
@@ -1235,7 +1240,7 @@ void spaces_to_tabs(Context& context, int ts)
 
 static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timestamp)
 {
-    SelectionList ranges;
+    SelectionList ranges(buffer);
     for (auto& change : buffer.changes_since(timestamp))
     {
         const ByteCoord& begin = change.begin;
@@ -1264,6 +1269,7 @@ static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timest
     if (ranges.empty())
         return ranges;
 
+    ranges.set_timestamp(buffer.timestamp());
     ranges.set_main_index(ranges.size() - 1);
 
     auto touches = [&](const Selection& lhs, const Selection& rhs) {
diff --git a/src/selection.cc b/src/selection.cc
index 0049689d..895c1f96 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -63,6 +63,7 @@ struct UpdateInsert
             coord.column = end.column + coord.column - begin.column;
 
         coord.line += end.line - begin.line;
+        kak_assert(coord.line >= 0 and coord.column >= 0);
     }
 };
 
@@ -78,7 +79,7 @@ struct UpdateErase
             kak_assert(end.line < coord.line);
         if (not assume_different_line and coord <= end)
         {
-            if (not at_end)
+            if (not at_end or begin == ByteCoord{0,0})
                 coord = begin;
             else
                 coord = begin.column ? ByteCoord{begin.line, begin.column-1}
@@ -94,11 +95,33 @@ struct UpdateErase
             else
                 coord.line -= end.line - begin.line;
         }
+        kak_assert(coord.line >= 0 and coord.column >= 0);
     }
 };
 
 }
 
+SelectionList::SelectionList(const Buffer& buffer)
+    : m_buffer(&buffer), m_timestamp(buffer.timestamp())
+{
+}
+
+SelectionList::SelectionList(const Buffer& buffer, Selection s, size_t timestamp)
+    : m_buffer(&buffer), m_selections({ s }), m_timestamp(timestamp)
+{}
+
+SelectionList::SelectionList(const Buffer& buffer, Selection s)
+    : SelectionList(buffer, s, buffer.timestamp())
+{}
+
+SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp)
+    : m_buffer(&buffer), m_selections(std::move(s)), m_timestamp(timestamp)
+{}
+
+SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s)
+    : SelectionList(buffer, std::move(s), buffer.timestamp())
+{}
+
 void SelectionList::update_insert(ByteCoord begin, ByteCoord end, bool at_end)
 {
     on_buffer_change<UpdateInsert>(*this, begin, end, at_end, begin.line);
@@ -109,12 +132,58 @@ void SelectionList::update_erase(ByteCoord begin, ByteCoord end, bool at_end)
     on_buffer_change<UpdateErase>(*this, begin, end, at_end, end.line);
 }
 
+void SelectionList::update()
+{
+    for (auto& change : m_buffer->changes_since(m_timestamp))
+    {
+        if (change.type == Buffer::Change::Insert)
+            update_insert(change.begin, change.end, change.at_end);
+        else
+            update_erase(change.begin, change.end, change.at_end);
+    }
+    m_timestamp = m_buffer->timestamp();
+
+    check_invariant();
+}
+
 void SelectionList::check_invariant() const
 {
+#ifdef KAK_DEBUG
+    auto& buffer = this->buffer();
     kak_assert(size() > 0);
     kak_assert(m_main < size());
     for (size_t i = 0; i+1 < size(); ++ i)
         kak_assert((*this)[i].min() <= (*this)[i+1].min());
+
+    for (size_t i = 0; i < size(); ++i)
+    {
+        auto& sel = (*this)[i];
+        kak_assert(buffer.is_valid(sel.anchor()));
+        kak_assert(buffer.is_valid(sel.cursor()));
+        kak_assert(not buffer.is_end(sel.anchor()));
+        kak_assert(not buffer.is_end(sel.cursor()));
+        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.anchor())));
+        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.cursor())));
+    }
+#endif
+}
+
+void SelectionList::sort_and_merge_overlapping()
+{
+    if (size() == 1)
+        return;
+
+    const auto& main = this->main();
+    const auto main_begin = main.min();
+    m_main = std::count_if(begin(), end(), [&](const Selection& sel) {
+                               auto begin = sel.min();
+                               if (begin == main_begin)
+                                   return &sel < &main;
+                               else
+                                   return begin < main_begin;
+                           });
+    std::stable_sort(begin(), end(), compare_selections);
+    merge_overlapping(overlaps);
 }
 
 }
diff --git a/src/selection.hh b/src/selection.hh
index 016ce5f5..9b3f747a 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -12,7 +12,7 @@ using CaptureList = std::vector<String>;
 struct Selection
 {
     Selection() = default;
-    explicit Selection(ByteCoord pos) : Selection(pos,pos) {}
+    Selection(ByteCoord pos) : Selection(pos,pos) {}
     Selection(ByteCoord anchor, ByteCoord cursor,
               CaptureList captures = {})
         : m_anchor{anchor}, m_cursor{cursor},
@@ -57,13 +57,17 @@ static bool compare_selections(const Selection& lhs, const Selection& rhs)
 
 struct SelectionList
 {
-    SelectionList() = default;
-    SelectionList(ByteCoord c) : m_selections{Selection{c,c}} {}
-    SelectionList(Selection s) : m_selections{s} {}
+    SelectionList(const Buffer& buffer);
+    SelectionList(const Buffer& buffer, Selection s);
+    SelectionList(const Buffer& buffer, Selection s, size_t timestamp);
+    SelectionList(const Buffer& buffer, std::vector<Selection> s);
+    SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp);
 
     void update_insert(ByteCoord begin, ByteCoord end, bool at_end);
     void update_erase(ByteCoord begin, ByteCoord end, bool at_end);
 
+    void update();
+
     void check_invariant() const;
 
     const Selection& main() const { return (*this)[m_main]; }
@@ -102,8 +106,8 @@ struct SelectionList
     size_t size() const { return m_selections.size(); }
     bool empty() const { return m_selections.empty(); }
 
-    bool operator==(const SelectionList& other) const { return m_selections == other.m_selections; }
-    bool operator!=(const SelectionList& other) const { return m_selections != other.m_selections; }
+    bool operator==(const SelectionList& other) const { return m_buffer == other.m_buffer and m_selections == other.m_selections; }
+    bool operator!=(const SelectionList& other) const { return !((*this) == other); }
 
     template<typename OverlapsFunc>
     void merge_overlapping(OverlapsFunc overlaps)
@@ -129,27 +133,19 @@ struct SelectionList
         kak_assert(std::is_sorted(begin(), end(), compare_selections));
     }
 
-    void sort_and_merge_overlapping()
-    {
-        if (size() == 1)
-            return;
+    void sort_and_merge_overlapping();
 
-        const auto& main = this->main();
-        const auto main_begin = main.min();
-        m_main = std::count_if(begin(), end(), [&](const Selection& sel) {
-                                   auto begin = sel.min();
-                                   if (begin == main_begin)
-                                       return &sel < &main;
-                                   else
-                                       return begin < main_begin;
-                               });
-        std::stable_sort(begin(), end(), compare_selections);
-        merge_overlapping(overlaps);
-    }
+    const Buffer& buffer() const { return *m_buffer; }
+
+    size_t timestamp() const { return m_timestamp; }
+    void set_timestamp(size_t timestamp) { m_timestamp = timestamp; }
 
 private:
     size_t m_main = 0;
     std::vector<Selection> m_selections;
+
+    safe_ptr<const Buffer> m_buffer;
+    size_t m_timestamp;
 };
 
 }
diff --git a/src/selectors.cc b/src/selectors.cc
index 5d98be52..40db98c9 100644
--- a/src/selectors.cc
+++ b/src/selectors.cc
@@ -431,13 +431,13 @@ Selection trim_partial_lines(const Buffer& buffer, const Selection& selection)
 
 void select_whole_buffer(const Buffer& buffer, SelectionList& selections)
 {
-    selections = SelectionList{ Selection({0,0}, buffer.back_coord()) };
+    selections = SelectionList{ buffer, Selection({0,0}, buffer.back_coord()) };
 }
 
 void select_all_matches(const Buffer& buffer, SelectionList& selections,
                         const Regex& regex)
 {
-    SelectionList result;
+    SelectionList result(buffer);
     for (auto& sel : selections)
     {
         auto sel_end = utf8::next(buffer.iterator_at(sel.max()));
@@ -470,7 +470,7 @@ void select_all_matches(const Buffer& buffer, SelectionList& selections,
 void split_selections(const Buffer& buffer, SelectionList& selections,
                       const Regex& regex)
 {
-    SelectionList result;
+    SelectionList result(buffer);
     for (auto& sel : selections)
     {
         auto begin = buffer.iterator_at(sel.min());
diff --git a/src/selectors.hh b/src/selectors.hh
index b28febef..d98b73bf 100644
--- a/src/selectors.hh
+++ b/src/selectors.hh
@@ -16,7 +16,7 @@ inline void clear_selections(const Buffer& buffer, SelectionList& selections)
     avoid_eol(buffer, pos);
     sel.anchor() = pos;
 
-    selections = SelectionList{ std::move(sel) };
+    selections = SelectionList{ buffer, std::move(sel) };
 }
 
 inline void flip_selections(SelectionList& selections)
@@ -31,7 +31,7 @@ inline void keep_selection(SelectionList& selections, int index)
     if (index < selections.size())
     {
         size_t real_index = (index + selections.main_index() + 1) % selections.size();
-        selections = SelectionList{ std::move(selections[real_index]) };
+        selections = SelectionList{ selections.buffer(), std::move(selections[real_index]) };
     }
     selections.check_invariant();
 }
diff --git a/src/window.cc b/src/window.cc
index 90c4ded6..fa6c9af9 100644
--- a/src/window.cc
+++ b/src/window.cc
@@ -23,7 +23,7 @@ Window::Window(Buffer& buffer)
       m_options(buffer.options()),
       m_keymaps(buffer.keymaps())
 {
-    InputHandler hook_handler{*m_buffer, { Selection{} } };
+    InputHandler hook_handler{{ *m_buffer, Selection{} }};
     hook_handler.context().set_window(*this);
     m_hooks.run_hook("WinCreate", buffer.name(), hook_handler.context());
     m_options.register_watcher(*this);
@@ -38,7 +38,7 @@ Window::Window(Buffer& buffer)
 
 Window::~Window()
 {
-    InputHandler hook_handler{*m_buffer, { Selection{} } };
+    InputHandler hook_handler{{ *m_buffer, Selection{} }};
     hook_handler.context().set_window(*this);
     m_hooks.run_hook("WinClose", buffer().name(), hook_handler.context());
     m_options.unregister_watcher(*this);
@@ -262,7 +262,7 @@ ByteCoord Window::offset_coord(ByteCoord coord, LineCount offset)
     lines.emplace_back(AtomList{ {buffer(), line, line+1} });
     display_buffer.compute_range();
 
-    InputHandler hook_handler{*m_buffer, { Selection{} } };
+    InputHandler hook_handler{{ *m_buffer, Selection{} } };
     hook_handler.context().set_window(*this);
     m_highlighters(hook_handler.context(), HighlightFlags::MoveOnly, display_buffer);
     m_builtin_highlighters(hook_handler.context(), HighlightFlags::MoveOnly, display_buffer);
@@ -274,7 +274,7 @@ ByteCoord Window::offset_coord(ByteCoord coord, LineCount offset)
 void Window::on_option_changed(const Option& option)
 {
     String desc = option.name() + "=" + option.get_as_string();
-    InputHandler hook_handler{*m_buffer, { Selection{} } };
+    InputHandler hook_handler{{ *m_buffer, Selection{} }};
     hook_handler.context().set_window(*this);
     m_hooks.run_hook("WinSetOption", desc, hook_handler.context());
 

From a06094b00e92d34e9f0be6abf80e5f4ce64998b3 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Tue, 13 May 2014 20:09:37 +0100
Subject: [PATCH 07/53] Use simple SelectionList for the Context::JumpList

---
 src/context.cc | 21 ++++++++++++++-------
 src/context.hh |  6 +++---
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/context.cc b/src/context.cc
index dac65284..9dcc87e4 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -103,8 +103,7 @@ void Context::push_jump()
     if (m_current_jump != m_jump_list.end())
     {
         auto begin = m_current_jump;
-        if (&buffer() != &begin->buffer() or
-            (const SelectionList&)(*begin) != jump)
+        if (&buffer() != &begin->buffer() or *begin != jump)
             ++begin;
         m_jump_list.erase(begin, m_jump_list.end());
     }
@@ -114,21 +113,27 @@ void Context::push_jump()
     m_current_jump = m_jump_list.end();
 }
 
-const DynamicSelectionList& Context::jump_forward()
+const SelectionList& Context::jump_forward()
 {
     if (m_current_jump != m_jump_list.end() and
         m_current_jump + 1 != m_jump_list.end())
-        return *++m_current_jump;
+    {
+        SelectionList& res = *++m_current_jump;
+        res.update();
+        return res;
+    }
     throw runtime_error("no next jump");
 }
 
-const DynamicSelectionList& Context::jump_backward()
+const SelectionList& Context::jump_backward()
 {
     if (m_current_jump != m_jump_list.end() and
         *m_current_jump != selections())
     {
         push_jump();
-        return *--m_current_jump;
+        SelectionList& res = *--m_current_jump;
+        res.update();
+        return res;
     }
     if (m_current_jump != m_jump_list.begin())
     {
@@ -137,7 +142,9 @@ const DynamicSelectionList& Context::jump_backward()
             push_jump();
             --m_current_jump;
         }
-        return *--m_current_jump;
+        SelectionList& res = *--m_current_jump;
+        res.update();
+        return res;
     }
     throw runtime_error("no previous jump");
 }
diff --git a/src/context.hh b/src/context.hh
index f612e36a..786386e2 100644
--- a/src/context.hh
+++ b/src/context.hh
@@ -64,8 +64,8 @@ public:
     void print_status(DisplayLine status) const;
 
     void push_jump();
-    const DynamicSelectionList& jump_forward();
-    const DynamicSelectionList& jump_backward();
+    const SelectionList& jump_forward();
+    const SelectionList& jump_backward();
     void forget_jumps_to_buffer(Buffer& buffer);
 
     const String& name() const { return m_name; }
@@ -89,7 +89,7 @@ private:
 
     String m_name;
 
-    using JumpList = std::vector<DynamicSelectionList>;
+    using JumpList = std::vector<SelectionList>;
     JumpList           m_jump_list;
     JumpList::iterator m_current_jump = m_jump_list.begin();
 };

From 11d9b607668d56c8deaf9062d48d9ce7aa6f5928 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Tue, 13 May 2014 23:22:54 +0100
Subject: [PATCH 08/53] Make it harder to have an invalid SelectionList

---
 src/dynamic_selection_list.cc |  6 ++---
 src/normal.cc                 | 47 +++++++++++++++++------------------
 src/selection.cc              | 28 ++++++++++-----------
 src/selection.hh              | 16 +++++++++---
 src/selectors.cc              |  6 ++---
 5 files changed, 53 insertions(+), 50 deletions(-)

diff --git a/src/dynamic_selection_list.cc b/src/dynamic_selection_list.cc
index 4087bb0c..f49b36c7 100644
--- a/src/dynamic_selection_list.cc
+++ b/src/dynamic_selection_list.cc
@@ -19,14 +19,12 @@ DynamicSelectionList& DynamicSelectionList::operator=(SelectionList selections)
 
 void DynamicSelectionList::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    update_insert(begin, end, at_end);
-    set_timestamp(buffer.timestamp());
+    update();
 }
 
 void DynamicSelectionList::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    update_erase(begin, end, at_end);
-    set_timestamp(buffer.timestamp());
+    update();
 }
 
 }
diff --git a/src/normal.cc b/src/normal.cc
index 7ac51ad5..15068fce 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -739,7 +739,7 @@ void split_lines(Context& context, int)
 {
     auto& selections = context.selections();
     auto& buffer = context.buffer();
-    SelectionList res(context.buffer());
+    std::vector<Selection> res;
     for (auto& sel : selections)
     {
         if (sel.anchor().line == sel.cursor().line)
@@ -754,14 +754,13 @@ void split_lines(Context& context, int)
             res.push_back({line, {line, buffer[line].length()-1}});
         res.push_back({max.line, max});
     }
-    res.set_main_index(res.size() - 1);
     selections = std::move(res);
 }
 
 void join_select_spaces(Context& context, int)
 {
     auto& buffer = context.buffer();
-    SelectionList selections(buffer);
+    std::vector<Selection> selections;
     for (auto& sel : context.selections())
     {
         for (LineCount line = sel.min().line; line <= sel.max().line; ++line)
@@ -776,7 +775,6 @@ void join_select_spaces(Context& context, int)
     }
     if (selections.empty())
         return;
-    selections.sort_and_merge_overlapping();
     context.selections() = selections;
     ScopedEdition edition(context);
     insert<InsertMode::Replace>(buffer, context.selections(), " ");
@@ -801,7 +799,7 @@ void keep(Context& context, int)
         if (ex.empty())
             return;
         const Buffer& buffer = context.buffer();
-        SelectionList keep(buffer);
+        std::vector<Selection> keep;
         for (auto& sel : context.selections())
         {
             if (boost::regex_search(buffer.iterator_at(sel.min()),
@@ -823,7 +821,7 @@ void keep_pipe(Context& context, int)
                 return;
             const Buffer& buffer = context.buffer();
             auto& shell_manager = ShellManager::instance();
-            SelectionList keep(buffer);
+            std::vector<Selection> keep;
             for (auto& sel : context.selections())
             {
                 int status = 0;
@@ -844,7 +842,7 @@ void indent(Context& context, int)
     String indent = indent_width == 0 ? "\t" : String{' ', indent_width};
 
     auto& buffer = context.buffer();
-    SelectionList sels(buffer);
+    std::vector<Selection> sels;
     for (auto& sel : context.selections())
     {
         for (auto line = sel.min().line; line < sel.max().line+1; ++line)
@@ -856,7 +854,8 @@ void indent(Context& context, int)
     if (not sels.empty())
     {
         ScopedEdition edition(context);
-        insert<InsertMode::Insert>(buffer, sels, indent);
+        SelectionList selections{buffer, std::move(sels)};
+        insert<InsertMode::Insert>(buffer, selections, indent);
     }
 }
 
@@ -869,7 +868,7 @@ void deindent(Context& context, int)
         indent_width = tabstop;
 
     auto& buffer = context.buffer();
-    SelectionList sels(buffer);
+    std::vector<Selection> sels;
     for (auto& sel : context.selections())
     {
         for (auto line = sel.min().line; line < sel.max().line+1; ++line)
@@ -900,7 +899,8 @@ void deindent(Context& context, int)
     if (not sels.empty())
     {
         ScopedEdition edition(context);
-        erase(context.buffer(), sels);
+        SelectionList selections{context.buffer(), std::move(sels)};
+        erase(context.buffer(), selections);
     }
 }
 
@@ -1238,16 +1238,16 @@ void spaces_to_tabs(Context& context, int ts)
     }
 }
 
-static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timestamp)
+static boost::optional<SelectionList> compute_modified_ranges(const Buffer& buffer, size_t timestamp)
 {
-    SelectionList ranges(buffer);
+    std::vector<Selection> ranges;
     for (auto& change : buffer.changes_since(timestamp))
     {
         const ByteCoord& begin = change.begin;
         const ByteCoord& end = change.end;
         if (change.type == Buffer::Change::Insert)
         {
-            ranges.update_insert(begin, end, change.at_end);
+            update_insert(ranges, begin, end, change.at_end);
             auto it = std::upper_bound(ranges.begin(), ranges.end(), begin,
                                        [](ByteCoord c, const Selection& sel)
                                        { return c < sel.min(); });
@@ -1255,7 +1255,7 @@ static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timest
         }
         else
         {
-            ranges.update_erase(begin, end, change.at_end);
+            update_erase(ranges, begin, end, change.at_end);
             auto pos = begin;
             if (change.at_end)
                 pos = begin.column ? ByteCoord{begin.line, begin.column - 1}
@@ -1267,23 +1267,22 @@ static SelectionList compute_modified_ranges(const Buffer& buffer, size_t timest
         }
     }
     if (ranges.empty())
-        return ranges;
+        return {};
 
-    ranges.set_timestamp(buffer.timestamp());
-    ranges.set_main_index(ranges.size() - 1);
+    SelectionList result{buffer, std::move(ranges)};
 
     auto touches = [&](const Selection& lhs, const Selection& rhs) {
         return lhs.min() <= rhs.min() ? buffer.char_next(lhs.max()) >= rhs.min()
                                       : lhs.min() <= buffer.char_next(rhs.max());
     };
-    ranges.merge_overlapping(touches);
+    result.merge_overlapping(touches);
 
-    for (auto& sel : ranges)
+    for (auto& sel : result)
     {
         if (sel.anchor() != sel.cursor())
             sel.cursor() = buffer.char_prev(sel.cursor());
     }
-    return ranges;
+    return result;
 }
 
 void undo(Context& context, int)
@@ -1294,8 +1293,8 @@ void undo(Context& context, int)
     if (res)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
-        if (not ranges.empty())
-            context.selections() = std::move(ranges);
+        if (ranges)
+            context.selections() = std::move(*ranges);
     }
     else if (not res)
         context.print_status({ "nothing left to undo", get_color("Information") });
@@ -1310,8 +1309,8 @@ void redo(Context& context, int)
     if (res)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
-        if (not ranges.empty())
-            context.selections() = std::move(ranges);
+        if (ranges)
+            context.selections() = std::move(*ranges);
     }
 
     else if (not res)
diff --git a/src/selection.cc b/src/selection.cc
index 895c1f96..3dee22ec 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -18,7 +18,7 @@ namespace
 {
 
 template<template <bool, bool> class UpdateFunc>
-void on_buffer_change(SelectionList& sels,
+void on_buffer_change(std::vector<Selection>& sels,
                       ByteCoord begin, ByteCoord end, bool at_end, LineCount end_line)
 {
     auto update_beg = std::lower_bound(sels.begin(), sels.end(), begin,
@@ -101,14 +101,11 @@ struct UpdateErase
 
 }
 
-SelectionList::SelectionList(const Buffer& buffer)
-    : m_buffer(&buffer), m_timestamp(buffer.timestamp())
-{
-}
-
 SelectionList::SelectionList(const Buffer& buffer, Selection s, size_t timestamp)
     : m_buffer(&buffer), m_selections({ s }), m_timestamp(timestamp)
-{}
+{
+    check_invariant();
+}
 
 SelectionList::SelectionList(const Buffer& buffer, Selection s)
     : SelectionList(buffer, s, buffer.timestamp())
@@ -116,20 +113,23 @@ SelectionList::SelectionList(const Buffer& buffer, Selection s)
 
 SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp)
     : m_buffer(&buffer), m_selections(std::move(s)), m_timestamp(timestamp)
-{}
+{
+    kak_assert(size() > 0);
+    check_invariant();
+}
 
 SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s)
     : SelectionList(buffer, std::move(s), buffer.timestamp())
 {}
 
-void SelectionList::update_insert(ByteCoord begin, ByteCoord end, bool at_end)
+void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    on_buffer_change<UpdateInsert>(*this, begin, end, at_end, begin.line);
+    on_buffer_change<UpdateInsert>(sels, begin, end, at_end, begin.line);
 }
 
-void SelectionList::update_erase(ByteCoord begin, ByteCoord end, bool at_end)
+void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end)
 {
-    on_buffer_change<UpdateErase>(*this, begin, end, at_end, end.line);
+    on_buffer_change<UpdateErase>(sels, begin, end, at_end, end.line);
 }
 
 void SelectionList::update()
@@ -137,9 +137,9 @@ void SelectionList::update()
     for (auto& change : m_buffer->changes_since(m_timestamp))
     {
         if (change.type == Buffer::Change::Insert)
-            update_insert(change.begin, change.end, change.at_end);
+            update_insert(m_selections, change.begin, change.end, change.at_end);
         else
-            update_erase(change.begin, change.end, change.at_end);
+            update_erase(m_selections, change.begin, change.end, change.at_end);
     }
     m_timestamp = m_buffer->timestamp();
 
diff --git a/src/selection.hh b/src/selection.hh
index 9b3f747a..f8727b90 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -57,15 +57,11 @@ static bool compare_selections(const Selection& lhs, const Selection& rhs)
 
 struct SelectionList
 {
-    SelectionList(const Buffer& buffer);
     SelectionList(const Buffer& buffer, Selection s);
     SelectionList(const Buffer& buffer, Selection s, size_t timestamp);
     SelectionList(const Buffer& buffer, std::vector<Selection> s);
     SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp);
 
-    void update_insert(ByteCoord begin, ByteCoord end, bool at_end);
-    void update_erase(ByteCoord begin, ByteCoord end, bool at_end);
-
     void update();
 
     void check_invariant() const;
@@ -83,6 +79,15 @@ struct SelectionList
     Selection& operator[](size_t i) { return m_selections[i]; }
     const Selection& operator[](size_t i) const { return m_selections[i]; }
 
+    SelectionList& operator=(std::vector<Selection> list)
+    {
+        m_selections = std::move(list);
+        m_main = size()-1;
+        sort_and_merge_overlapping();
+        check_invariant();
+        return *this;
+    }
+
     using iterator = std::vector<Selection>::iterator;
     iterator begin() { return m_selections.begin(); }
     iterator end() { return m_selections.end(); }
@@ -148,6 +153,9 @@ private:
     size_t m_timestamp;
 };
 
+void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end);
+void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end);
+
 }
 
 #endif // selection_hh_INCLUDED
diff --git a/src/selectors.cc b/src/selectors.cc
index 40db98c9..2e823d9d 100644
--- a/src/selectors.cc
+++ b/src/selectors.cc
@@ -437,7 +437,7 @@ void select_whole_buffer(const Buffer& buffer, SelectionList& selections)
 void select_all_matches(const Buffer& buffer, SelectionList& selections,
                         const Regex& regex)
 {
-    SelectionList result(buffer);
+    std::vector<Selection> result;
     for (auto& sel : selections)
     {
         auto sel_end = utf8::next(buffer.iterator_at(sel.max()));
@@ -463,14 +463,13 @@ void select_all_matches(const Buffer& buffer, SelectionList& selections,
     }
     if (result.empty())
         throw runtime_error("nothing selected");
-    result.set_main_index(result.size() - 1);
     selections = std::move(result);
 }
 
 void split_selections(const Buffer& buffer, SelectionList& selections,
                       const Regex& regex)
 {
-    SelectionList result(buffer);
+    std::vector<Selection> result;
     for (auto& sel : selections)
     {
         auto begin = buffer.iterator_at(sel.min());
@@ -489,7 +488,6 @@ void split_selections(const Buffer& buffer, SelectionList& selections,
         if (begin.coord() <= sel.max())
             result.push_back({ begin.coord(), sel.max() });
     }
-    result.set_main_index(result.size() - 1);
     selections = std::move(result);
 }
 

From fbf7856e3ec40d58444d88fc9852db8e38cb68e7 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 00:27:41 +0100
Subject: [PATCH 09/53] use plain SelectionList for regex_prompt

---
 src/normal.cc | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index 15068fce..14526d2f 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -599,13 +599,14 @@ void paste(Context& context, int)
 template<typename T>
 void regex_prompt(Context& context, const String prompt, T func)
 {
-    DynamicSelectionList selections{context.selections()};
+    SelectionList selections = context.selections();
     context.input_handler().prompt(prompt, "", get_color("Prompt"), complete_nothing,
-        [=](const String& str, PromptEvent event, Context& context) {
+        [=](const String& str, PromptEvent event, Context& context) mutable {
             try
             {
                 if (event != PromptEvent::Change and context.has_ui())
                     context.ui().info_hide();
+                selections.update();
                 context.selections() = selections;
                 context.input_handler().set_prompt_colors(get_color("Prompt"));
                 if (event == PromptEvent::Abort)

From db423e4a88be8799ce0cfae33ddbf4c6bae97e5f Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 19:21:19 +0100
Subject: [PATCH 10/53] utf8::is_character_start takes directly the char value

---
 src/selection.cc | 4 ++--
 src/utf8.hh      | 7 +++----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/selection.cc b/src/selection.cc
index 3dee22ec..0d90cc35 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -162,8 +162,8 @@ void SelectionList::check_invariant() const
         kak_assert(buffer.is_valid(sel.cursor()));
         kak_assert(not buffer.is_end(sel.anchor()));
         kak_assert(not buffer.is_end(sel.cursor()));
-        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.anchor())));
-        kak_assert(utf8::is_character_start(buffer.iterator_at(sel.cursor())));
+        kak_assert(utf8::is_character_start(buffer.byte_at(sel.anchor())));
+        kak_assert(utf8::is_character_start(buffer.byte_at(sel.cursor())));
     }
 #endif
 }
diff --git a/src/utf8.hh b/src/utf8.hh
index 865d8705..5aac8c2a 100644
--- a/src/utf8.hh
+++ b/src/utf8.hh
@@ -76,17 +76,16 @@ CharCount distance(Iterator begin, Iterator end)
 
 // return true if it points to the first byte of a (either single or
 // multibyte) character
-template<typename Iterator>
-bool is_character_start(Iterator it)
+inline bool is_character_start(char c)
 {
-    return (*it & 0xC0) != 0x80;
+    return (c & 0xC0) != 0x80;
 }
 
 // returns an iterator to the first byte of the character it is into
 template<typename Iterator>
 Iterator character_start(Iterator it)
 {
-    while (not is_character_start(it))
+    while (not is_character_start(*it))
         --it;
     return it;
 }

From bf98b38afd5338f6be617cfaf4bb251eb011e2b0 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 00:59:36 +0100
Subject: [PATCH 11/53] Use a plain SelectionList for Context, remove
 DynamicSelectionList

---
 src/context.cc                |  9 ++++-----
 src/context.hh                |  4 ++--
 src/dynamic_selection_list.cc | 30 ------------------------------
 src/dynamic_selection_list.hh | 30 ------------------------------
 src/input_handler.cc          |  9 ++++++++-
 src/insert_completer.cc       |  6 ++++--
 src/normal.cc                 |  2 ++
 src/selection.cc              | 11 +++++++----
 8 files changed, 27 insertions(+), 74 deletions(-)
 delete mode 100644 src/dynamic_selection_list.cc
 delete mode 100644 src/dynamic_selection_list.hh

diff --git a/src/context.cc b/src/context.cc
index 9dcc87e4..e909f1f5 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -21,7 +21,7 @@ Buffer& Context::buffer() const
 {
     if (not has_buffer())
         throw runtime_error("no buffer in context");
-    return (*m_selections).registry();
+    return const_cast<Buffer&>((*m_selections).buffer());
 }
 
 Window& Context::window() const
@@ -175,7 +175,7 @@ void Context::change_buffer(Buffer& buffer)
     if (has_client())
         client().change_buffer(buffer);
     else
-        m_selections = DynamicSelectionList{ { buffer, Selection{} } };
+        m_selections = SelectionList{buffer, Selection{}};
     if (has_input_handler())
         input_handler().reset_normal_mode();
 }
@@ -184,14 +184,13 @@ SelectionList& Context::selections()
 {
     if (not m_selections)
         throw runtime_error("no selections in context");
+    (*m_selections).update();
     return *m_selections;
 }
 
 const SelectionList& Context::selections() const
 {
-    if (not m_selections)
-        throw runtime_error("no selections in context");
-    return *m_selections;
+    return const_cast<Context&>(*this).selections();
 }
 
 std::vector<String> Context::selections_content() const
diff --git a/src/context.hh b/src/context.hh
index 786386e2..90961216 100644
--- a/src/context.hh
+++ b/src/context.hh
@@ -1,7 +1,7 @@
 #ifndef context_hh_INCLUDED
 #define context_hh_INCLUDED
 
-#include "dynamic_selection_list.hh"
+#include "selection.hh"
 
 #include <boost/optional.hpp>
 
@@ -85,7 +85,7 @@ private:
     safe_ptr<Client>       m_client;
 
     friend class Client;
-    boost::optional<DynamicSelectionList> m_selections;
+    boost::optional<SelectionList> m_selections;
 
     String m_name;
 
diff --git a/src/dynamic_selection_list.cc b/src/dynamic_selection_list.cc
deleted file mode 100644
index f49b36c7..00000000
--- a/src/dynamic_selection_list.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "dynamic_selection_list.hh"
-
-namespace Kakoune
-{
-
-DynamicSelectionList::DynamicSelectionList(SelectionList selections)
-    : SelectionList(std::move(selections)),
-      BufferChangeListener_AutoRegister(const_cast<Buffer&>(buffer()))
-{
-    check_invariant();
-}
-
-DynamicSelectionList& DynamicSelectionList::operator=(SelectionList selections)
-{
-    SelectionList::operator=(std::move(selections));
-    check_invariant();
-    return *this;
-}
-
-void DynamicSelectionList::on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
-{
-    update();
-}
-
-void DynamicSelectionList::on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end)
-{
-    update();
-}
-
-}
diff --git a/src/dynamic_selection_list.hh b/src/dynamic_selection_list.hh
deleted file mode 100644
index 65f37915..00000000
--- a/src/dynamic_selection_list.hh
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef dynamic_selection_list_hh_INCLUDED
-#define dynamic_selection_list_hh_INCLUDED
-
-#include "selection.hh"
-
-namespace Kakoune
-{
-
-class DynamicSelectionList : public SelectionList,
-                             public BufferChangeListener_AutoRegister
-{
-public:
-    using iterator = SelectionList::iterator;
-    using const_iterator = SelectionList::const_iterator;
-
-    DynamicSelectionList(SelectionList selections);
-
-    DynamicSelectionList& operator=(SelectionList selections);
-
-    using SelectionList::buffer;
-
-private:
-    void on_insert(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end) override;
-    void on_erase(const Buffer& buffer, ByteCoord begin, ByteCoord end, bool at_end) override;
-};
-
-}
-
-#endif // dynamic_selection_list_hh_INCLUDED
-
diff --git a/src/input_handler.cc b/src/input_handler.cc
index 62e3068f..08cd7f44 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -764,6 +764,7 @@ private:
             size_t index = std::min(i, strings.size()-1);
             buffer.insert(buffer.iterator_at(selections[i].cursor()),
                           strings[index]);
+           selections.update();
         }
     }
 
@@ -771,8 +772,12 @@ private:
     {
         auto str = codepoint_to_str(key);
         auto& buffer = context().buffer();
-        for (auto& sel : context().selections())
+        auto& selections = context().selections();
+        for (auto& sel : selections)
+        {
             buffer.insert(buffer.iterator_at(sel.cursor()), str);
+            selections.update();
+        }
         context().hooks().run_hook("InsertChar", str, context());
     }
 
@@ -829,6 +834,8 @@ private:
                anchor = buffer.char_prev(anchor);
             if (buffer.is_end(cursor))
                cursor = buffer.char_prev(cursor);
+
+            selections.update();
             sel.anchor() = anchor;
             sel.cursor() = cursor;
         }
diff --git a/src/insert_completer.cc b/src/insert_completer.cc
index 7b7d52fe..def3b951 100644
--- a/src/insert_completer.cc
+++ b/src/insert_completer.cc
@@ -185,13 +185,14 @@ void InsertCompleter::select(int offset)
     if (m_current_candidate < 0)
         m_current_candidate += m_matching_candidates.size();
     const String& candidate = m_matching_candidates[m_current_candidate];
-    const auto& cursor_pos = m_context.selections().main().cursor();
+    auto& selections = m_context.selections();
+    const auto& cursor_pos = selections.main().cursor();
     const auto prefix_len = buffer.distance(m_completions.begin, cursor_pos);
     const auto suffix_len = std::max(0_byte, buffer.distance(cursor_pos, m_completions.end));
     const auto buffer_len = buffer.byte_count();
 
     auto ref = buffer.string(m_completions.begin, m_completions.end);
-    for (auto& sel : m_context.selections())
+    for (auto& sel : selections)
     {
         auto offset = buffer.offset(sel.cursor());
         auto pos = buffer.iterator_at(sel.cursor());
@@ -200,6 +201,7 @@ void InsertCompleter::select(int offset)
         {
             pos = buffer.erase(pos - prefix_len, pos + suffix_len);
             buffer.insert(pos, candidate);
+            const_cast<SelectionList&>(selections).update();
         }
     }
     m_completions.end   = cursor_pos;
diff --git a/src/normal.cc b/src/normal.cc
index 14526d2f..a8386b32 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -70,6 +70,7 @@ void insert(Buffer& buffer, SelectionList& selections, const String& str)
     {
         auto pos = prepare_insert<mode>(buffer, sel);
         pos = buffer.insert(pos, str);
+        selections.update();
         if (mode == InsertMode::Replace and pos != buffer.end())
         {
             sel.anchor() = pos.coord();
@@ -93,6 +94,7 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
         auto pos = prepare_insert<mode>(buffer, sel);
         const String& str = strings[std::min(i, strings.size()-1)];
         pos = buffer.insert(pos, str);
+        selections.update();
         if (mode == InsertMode::Replace and pos != buffer.end())
         {
             sel.anchor() = pos.coord();
diff --git a/src/selection.cc b/src/selection.cc
index 0d90cc35..746253f9 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -134,6 +134,9 @@ void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end,
 
 void SelectionList::update()
 {
+    if (m_timestamp == m_buffer->timestamp())
+        return;
+
     for (auto& change : m_buffer->changes_since(m_timestamp))
     {
         if (change.type == Buffer::Change::Insert)
@@ -141,9 +144,10 @@ void SelectionList::update()
         else
             update_erase(m_selections, change.begin, change.end, change.at_end);
     }
-    m_timestamp = m_buffer->timestamp();
 
     check_invariant();
+
+    m_timestamp = m_buffer->timestamp();
 }
 
 void SelectionList::check_invariant() const
@@ -152,12 +156,11 @@ void SelectionList::check_invariant() const
     auto& buffer = this->buffer();
     kak_assert(size() > 0);
     kak_assert(m_main < size());
-    for (size_t i = 0; i+1 < size(); ++ i)
-        kak_assert((*this)[i].min() <= (*this)[i+1].min());
-
     for (size_t i = 0; i < size(); ++i)
     {
         auto& sel = (*this)[i];
+        if (i+1 < size())
+            kak_assert((*this)[i].min() <= (*this)[i+1].min());
         kak_assert(buffer.is_valid(sel.anchor()));
         kak_assert(buffer.is_valid(sel.cursor()));
         kak_assert(not buffer.is_end(sel.anchor()));

From c3f4ef9ba2e8ca58acc6cf56e552341a5af62f5d Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 01:01:46 +0100
Subject: [PATCH 12/53] Remove BufferChangeListener

---
 src/buffer.cc | 13 -------------
 src/buffer.hh | 39 ---------------------------------------
 2 files changed, 52 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index 4e7c2606..56a4350d 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -68,16 +68,10 @@ Buffer::~Buffer()
     m_options.unregister_watcher(*this);
     BufferManager::instance().unregister_buffer(*this);
     m_values.clear();
-    kak_assert(m_change_listeners.empty());
 }
 
 void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
 {
-    // use back coord to simulate the persistance of the last end of line
-    // as buffers are expected to never be empty.
-    for (auto listener : m_change_listeners)
-        listener->on_erase(*this, {0,0}, back_coord(), true);
-
     m_changes.push_back({ Change::Erase, {0,0}, back_coord(), true });
 
     m_history.clear();
@@ -100,9 +94,6 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     m_fs_timestamp = fs_timestamp;
 
     m_changes.push_back({ Change::Insert, {0,0}, back_coord(), true });
-
-    for (auto listener : m_change_listeners)
-        listener->on_insert(*this, {0,0}, back_coord(), true);
 }
 
 String Buffer::display_name() const
@@ -522,8 +513,6 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
     }
 
     m_changes.push_back({ Change::Insert, begin, end, at_end });
-    for (auto listener : m_change_listeners)
-        listener->on_insert(*this, begin, end, at_end);
     return begin;
 }
 
@@ -553,8 +542,6 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
         m_lines[i].start -= length;
 
     m_changes.push_back({ Change::Erase, begin, end, is_end(begin) });
-    for (auto listener : m_change_listeners)
-        listener->on_erase(*this, begin, end, is_end(begin));
     return next;
 }
 
diff --git a/src/buffer.hh b/src/buffer.hh
index f817eef0..3a9b0426 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -63,15 +63,6 @@ private:
     ByteCoord m_coord;
 };
 
-class BufferChangeListener
-{
-public:
-    virtual void on_insert(const Buffer& buffer,
-                           ByteCoord begin, ByteCoord end, bool at_end) = 0;
-    virtual void on_erase(const Buffer& buffer,
-                          ByteCoord begin, ByteCoord end, bool at_end) = 0;
-};
-
 // A Buffer is a in-memory representation of a file
 //
 // The Buffer class permits to read and mutate this file
@@ -170,8 +161,6 @@ public:
 
     void run_hook_in_own_context(const String& hook_name, const String& param);
 
-    std::unordered_set<BufferChangeListener*>& change_listeners() const { return m_change_listeners; }
-
     void reload(std::vector<String> lines, time_t fs_timestamp = InvalidTime);
 
     void check_invariant() const;
@@ -230,10 +219,6 @@ private:
 
     time_t m_fs_timestamp;
 
-    // this is mutable as adding or removing listeners is not muting the
-    // buffer observable state.
-    mutable std::unordered_set<BufferChangeListener*> m_change_listeners;
-
     OptionManager m_options;
     HookManager   m_hooks;
     KeymapManager m_keymaps;
@@ -270,30 +255,6 @@ private:
     }
 };
 
-struct BufferListenerRegisterFuncs
-{
-    static void insert(const Buffer& buffer, BufferChangeListener& listener)
-    {
-        buffer.change_listeners().insert(&listener);
-    }
-    static void remove(const Buffer& buffer, BufferChangeListener& listener)
-    {
-        buffer.change_listeners().erase(&listener);
-    }
-};
-
-class BufferChangeListener_AutoRegister
-    : public BufferChangeListener,
-      public AutoRegister<BufferChangeListener_AutoRegister,
-                          BufferListenerRegisterFuncs, Buffer>
-{
-public:
-    BufferChangeListener_AutoRegister(Buffer& buffer)
-        : AutoRegister(buffer) {}
-
-    Buffer& buffer() const { return registry(); }
-};
-
 }
 
 #include "buffer.inl.hh"

From 4e280977a2fcd7ca423b5909b435b896b256cdaf Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 20:56:27 +0100
Subject: [PATCH 13/53] Iterate in reversed order on selections when modifing
 buffer

This way, update only needs to be called once everything is done
as we always modify after the next selection to be used.
---
 src/buffer_utils.hh  | 14 --------------
 src/input_handler.cc | 28 ++++++++++++++--------------
 src/normal.cc        | 42 +++++++++++++++++++++++++-----------------
 src/selection.cc     | 26 ++++++++++++++++++++++++++
 src/selection.hh     |  6 ++++++
 src/selectors.hh     |  2 +-
 6 files changed, 72 insertions(+), 46 deletions(-)

diff --git a/src/buffer_utils.hh b/src/buffer_utils.hh
index bd617595..f47c2c26 100644
--- a/src/buffer_utils.hh
+++ b/src/buffer_utils.hh
@@ -24,20 +24,6 @@ inline CharCount char_length(const Buffer& buffer, const Selection& range)
                           utf8::next(buffer.iterator_at(range.max())));
 }
 
-inline void avoid_eol(const Buffer& buffer, ByteCoord& coord)
-{
-    const auto column = coord.column;
-    const auto& line = buffer[coord.line];
-    if (column != 0 and column == line.length() - 1)
-        coord.column = line.byte_count_to(line.char_length() - 2);
-}
-
-inline void avoid_eol(const Buffer& buffer, Selection& sel)
-{
-    avoid_eol(buffer, sel.anchor());
-    avoid_eol(buffer, sel.cursor());
-}
-
 CharCount get_column(const Buffer& buffer,
                      CharCount tabstop, ByteCoord coord);
 
diff --git a/src/input_handler.cc b/src/input_handler.cc
index 08cd7f44..459f6751 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -667,7 +667,7 @@ public:
         }
         else if (key == Key::Backspace)
         {
-            for (auto& sel : context().selections())
+            for (auto& sel : reversed(context().selections()))
             {
                 if (sel.cursor() == ByteCoord{0,0})
                     continue;
@@ -677,7 +677,7 @@ public:
         }
         else if (key == Key::Erase)
         {
-            for (auto& sel : context().selections())
+            for (auto& sel : reversed(context().selections()))
             {
                 auto pos = buffer.iterator_at(sel.cursor());
                 buffer.erase(pos, utf8::next(pos));
@@ -761,11 +761,12 @@ private:
         auto& selections = context().selections();
         for (size_t i = 0; i < selections.size(); ++i)
         {
-            size_t index = std::min(i, strings.size()-1);
-            buffer.insert(buffer.iterator_at(selections[i].cursor()),
-                          strings[index]);
-           selections.update();
+            size_t index = selections.size() - 1 - i;
+            const String& str = strings[std::min(index, strings.size()-1)];
+            buffer.insert(buffer.iterator_at(selections[index].cursor()),
+                          str);
         }
+        selections.update();
     }
 
     void insert(Codepoint key)
@@ -773,11 +774,9 @@ private:
         auto str = codepoint_to_str(key);
         auto& buffer = context().buffer();
         auto& selections = context().selections();
-        for (auto& sel : selections)
-        {
+        for (auto& sel : reversed(selections))
             buffer.insert(buffer.iterator_at(sel.cursor()), str);
-            selections.update();
-        }
+        selections.update();
         context().hooks().run_hook("InsertChar", str, context());
     }
 
@@ -786,7 +785,7 @@ private:
         SelectionList& selections = context().selections();
         Buffer& buffer = context().buffer();
 
-        for (auto& sel : selections)
+        for (auto& sel : reversed(selections))
         {
             ByteCoord anchor, cursor;
             switch (mode)
@@ -835,10 +834,10 @@ private:
             if (buffer.is_end(cursor))
                cursor = buffer.char_prev(cursor);
 
-            selections.update();
             sel.anchor() = anchor;
             sel.cursor() = cursor;
         }
+        selections.update();
         if (mode == InsertMode::OpenLineBelow or mode == InsertMode::OpenLineAbove)
         {
             insert('\n');
@@ -859,12 +858,13 @@ private:
 
     void on_disabled() override
     {
-        for (auto& sel : context().selections())
+        auto& selections = context().selections();
+        for (auto& sel : selections)
         {
             if (m_insert_mode == InsertMode::Append and sel.cursor().column > 0)
                 sel.cursor() = context().buffer().char_prev(sel.cursor());
-            avoid_eol(context().buffer(), sel);
         }
+        selections.avoid_eol();
     }
 
     enum class Mode { Default, Complete, InsertReg };
diff --git a/src/normal.cc b/src/normal.cc
index a8386b32..ff38c29d 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -23,13 +23,12 @@ namespace Kakoune
 
 void erase(Buffer& buffer, SelectionList& selections)
 {
-    for (auto& sel : selections)
+    for (auto& sel : reversed(selections))
     {
         erase(buffer, sel);
-        selections.update();
-        avoid_eol(buffer, sel);
     }
-    selections.check_invariant();
+    selections.update();
+    selections.avoid_eol();
     buffer.check_invariant();
 }
 
@@ -66,20 +65,24 @@ BufferIterator prepare_insert(Buffer& buffer, const Selection& sel)
 template<InsertMode mode>
 void insert(Buffer& buffer, SelectionList& selections, const String& str)
 {
-    for (auto& sel : selections)
+    for (auto& sel : reversed(selections))
     {
         auto pos = prepare_insert<mode>(buffer, sel);
         pos = buffer.insert(pos, str);
-        selections.update();
-        if (mode == InsertMode::Replace and pos != buffer.end())
+        if (mode == InsertMode::Replace)
         {
+            if (pos == buffer.end())
+                --pos;
             sel.anchor() = pos.coord();
             sel.cursor() = str.empty() ?
                 pos.coord() : (pos + str.byte_count_to(str.char_length() - 1)).coord();
         }
-        avoid_eol(buffer, sel);
     }
-    selections.check_invariant();
+    if (mode == InsertMode::Replace)
+        selections.set_timestamp(buffer.timestamp());
+    else
+        selections.update();
+    selections.avoid_eol();
     buffer.check_invariant();
 }
 
@@ -90,20 +93,25 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
         return;
     for (size_t i = 0; i < selections.size(); ++i)
     {
-        auto& sel = selections[i];
+        size_t index = selections.size() - 1 - i;
+        auto& sel = selections[index];
         auto pos = prepare_insert<mode>(buffer, sel);
-        const String& str = strings[std::min(i, strings.size()-1)];
+        const String& str = strings[std::min(index, strings.size()-1)];
         pos = buffer.insert(pos, str);
-        selections.update();
-        if (mode == InsertMode::Replace and pos != buffer.end())
+        if (mode == InsertMode::Replace)
         {
+             if (pos == buffer.end())
+                 --pos;
             sel.anchor() = pos.coord();
             sel.cursor() = (str.empty() ?
                 pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
         }
-        avoid_eol(buffer, sel);
     }
-    selections.check_invariant();
+    if (mode == InsertMode::Replace)
+        selections.set_timestamp(buffer.timestamp());
+    else
+        selections.update();
+    selections.avoid_eol();
     buffer.check_invariant();
 }
 
@@ -1352,9 +1360,9 @@ void move(Context& context, int count)
                                            : context.buffer().offset_coord(sel.cursor(), offset);
 
         sel.anchor() = mode == SelectMode::Extend ? sel.anchor() : cursor;
-        sel.cursor()  = cursor;
-        avoid_eol(context.buffer(), sel);
+        sel.cursor() = cursor;
     }
+    selections.avoid_eol();
     selections.sort_and_merge_overlapping();
 }
 
diff --git a/src/selection.cc b/src/selection.cc
index 746253f9..1e8356ab 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -188,5 +188,31 @@ void SelectionList::sort_and_merge_overlapping()
     std::stable_sort(begin(), end(), compare_selections);
     merge_overlapping(overlaps);
 }
+namespace
+{
+
+inline void _avoid_eol(const Buffer& buffer, ByteCoord& coord)
+{
+    const auto column = coord.column;
+    const auto& line = buffer[coord.line];
+    if (column != 0 and column == line.length() - 1)
+        coord.column = line.byte_count_to(line.char_length() - 2);
+}
+
+
+inline void _avoid_eol(const Buffer& buffer, Selection& sel)
+{
+    _avoid_eol(buffer, sel.anchor());
+    _avoid_eol(buffer, sel.cursor());
+}
+
+}
+
+void SelectionList::avoid_eol()
+{
+    update();
+    for (auto& sel : m_selections)
+        _avoid_eol(buffer(), sel);
+}
 
 }
diff --git a/src/selection.hh b/src/selection.hh
index f8727b90..5f0ce459 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -73,6 +73,8 @@ struct SelectionList
 
     void rotate_main(int count) { m_main = (m_main + count) % size(); }
 
+    void avoid_eol();
+
     void push_back(const Selection& sel) { m_selections.push_back(sel); }
     void push_back(Selection&& sel) { m_selections.push_back(std::move(sel)); }
 
@@ -92,6 +94,10 @@ struct SelectionList
     iterator begin() { return m_selections.begin(); }
     iterator end() { return m_selections.end(); }
 
+    using reverse_iterator = std::vector<Selection>::reverse_iterator;
+    reverse_iterator rbegin() { return m_selections.rbegin(); }
+    reverse_iterator rend() { return m_selections.rend(); }
+
     using const_iterator = std::vector<Selection>::const_iterator;
     const_iterator begin() const { return m_selections.begin(); }
     const_iterator end() const { return m_selections.end(); }
diff --git a/src/selectors.hh b/src/selectors.hh
index d98b73bf..d5b0523d 100644
--- a/src/selectors.hh
+++ b/src/selectors.hh
@@ -13,8 +13,8 @@ inline void clear_selections(const Buffer& buffer, SelectionList& selections)
 {
     auto& sel = selections.main();
     auto& pos = sel.cursor();
-    avoid_eol(buffer, pos);
     sel.anchor() = pos;
+    selections.avoid_eol();
 
     selections = SelectionList{ buffer, std::move(sel) };
 }

From 0ec0f7c32017a05056e8d008a3520cde83f03bf0 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 21:10:55 +0100
Subject: [PATCH 14/53] Remove unneeded vector for computing line modifications

---
 src/line_change_watcher.cc | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/line_change_watcher.cc b/src/line_change_watcher.cc
index c13a43b2..1a91f053 100644
--- a/src/line_change_watcher.cc
+++ b/src/line_change_watcher.cc
@@ -8,16 +8,9 @@ namespace Kakoune
 namespace
 {
 
-struct Change
+struct LineChange
 {
-    LineCount pos;
-    LineCount num;
-};
-
-std::vector<Change> compute_changes(const Buffer& buffer, size_t timestamp)
-{
-    std::vector<Change> res;
-    for (auto& change : buffer.changes_since(timestamp))
+    LineChange(const Buffer::Change& change)
     {
         ByteCoord begin = change.begin;
         ByteCoord end = change.end;
@@ -28,7 +21,8 @@ std::vector<Change> compute_changes(const Buffer& buffer, size_t timestamp)
                 kak_assert(begin.column == 0);
                 --begin.line;
             }
-            res.push_back({begin.line, end.line - begin.line});
+            pos = begin.line;
+            num = end.line - begin.line;
         }
         else
         {
@@ -37,11 +31,14 @@ std::vector<Change> compute_changes(const Buffer& buffer, size_t timestamp)
                 kak_assert(begin.column == 0);
                 --begin.line;
             }
-            res.push_back({begin.line, begin.line - end.line});
+            pos = begin.line;
+            num = begin.line - end.line;
         }
     }
-    return res;
-}
+
+    LineCount pos;
+    LineCount num;
+};
 
 }
 
@@ -51,8 +48,10 @@ LineChangeWatcher::LineChangeWatcher(const Buffer& buffer)
 std::vector<LineModification> LineChangeWatcher::compute_modifications()
 {
     std::vector<LineModification> res;
-    for (auto& change : compute_changes(*m_buffer, m_timestamp))
+    for (auto& buf_change : m_buffer->changes_since(m_timestamp))
     {
+        const LineChange change(buf_change);
+
         auto pos = std::upper_bound(res.begin(), res.end(), change.pos,
                                     [](const LineCount& l, const LineModification& c)
                                     { return l < c.new_line; });

From 2f1388df7bafec0d77b25abc27424c9f14629506 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 21:19:19 +0100
Subject: [PATCH 15/53] replace LineChangeWatcher with a free function
 compute_line_modifications

---
 src/highlighters.cc                                 | 13 +++++--------
 ...{line_change_watcher.cc => line_modification.cc} | 10 +++-------
 ...{line_change_watcher.hh => line_modification.hh} | 13 +------------
 src/word_db.cc                                      | 10 +++++++---
 src/word_db.hh                                      |  4 ++--
 5 files changed, 18 insertions(+), 32 deletions(-)
 rename src/{line_change_watcher.cc => line_modification.cc} (89%)
 rename src/{line_change_watcher.hh => line_modification.hh} (67%)

diff --git a/src/highlighters.cc b/src/highlighters.cc
index cc484b88..f3f2af60 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -5,7 +5,7 @@
 #include "color_registry.hh"
 #include "context.hh"
 #include "display_buffer.hh"
-#include "line_change_watcher.hh"
+#include "line_modification.hh"
 #include "option_types.hh"
 #include "register_manager.hh"
 #include "string.hh"
@@ -158,7 +158,7 @@ struct BufferSideCache
     {
         Value& cache_val = buffer.values()[m_id];
         if (not cache_val)
-            cache_val = Value(T{buffer});
+            cache_val = Value(T{});
         return cache_val.as<T>();
     }
 private:
@@ -195,7 +195,6 @@ public:
 private:
     struct Cache
     {
-        Cache(const Buffer&){}
         BufferRange m_range;
         size_t      m_timestamp = 0;
         std::vector<std::vector<std::pair<ByteCoord, ByteCoord>>> m_matches;
@@ -671,10 +670,8 @@ private:
                                       : lhs.begin < rhs.begin;
     }
 
-    struct Cache : public LineChangeWatcher
+    struct Cache
     {
-        Cache(const Buffer& buffer) : LineChangeWatcher(buffer) {}
-
         size_t timestamp = 0;
         MatchList begin_matches;
         MatchList end_matches;
@@ -696,7 +693,7 @@ private:
         }
         else
         {
-            auto modifs = cache.compute_modifications();
+            auto modifs = compute_line_modifications(buffer, cache.timestamp);
             update_matches(buffer, modifs, cache.begin_matches, m_begin);
             update_matches(buffer, modifs, cache.end_matches, m_end);
         }
@@ -718,7 +715,7 @@ private:
             beg_it = std::upper_bound(beg_it, cache.begin_matches.end(),
                                       *end_it, compare_matches_end);
         }
-        cache.timestamp = buffer.timestamp();
+        cache.timestamp = buf_timestamp;
         return cache.regions;
     }
 
diff --git a/src/line_change_watcher.cc b/src/line_modification.cc
similarity index 89%
rename from src/line_change_watcher.cc
rename to src/line_modification.cc
index 1a91f053..5da287fc 100644
--- a/src/line_change_watcher.cc
+++ b/src/line_modification.cc
@@ -1,4 +1,4 @@
-#include "line_change_watcher.hh"
+#include "line_modification.hh"
 
 #include "buffer.hh"
 
@@ -42,13 +42,10 @@ struct LineChange
 
 }
 
-LineChangeWatcher::LineChangeWatcher(const Buffer& buffer)
-    : m_buffer(&buffer), m_timestamp(buffer.timestamp()) {}
-
-std::vector<LineModification> LineChangeWatcher::compute_modifications()
+std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp)
 {
     std::vector<LineModification> res;
-    for (auto& buf_change : m_buffer->changes_since(m_timestamp))
+    for (auto& buf_change : buffer.changes_since(timestamp))
     {
         const LineChange change(buf_change);
 
@@ -102,7 +99,6 @@ std::vector<LineModification> LineChangeWatcher::compute_modifications()
                 it->new_line -= num_removed;
         }
     }
-    m_timestamp = m_buffer->timestamp();
     return res;
 }
 
diff --git a/src/line_change_watcher.hh b/src/line_modification.hh
similarity index 67%
rename from src/line_change_watcher.hh
rename to src/line_modification.hh
index d35167ca..3cd2d669 100644
--- a/src/line_change_watcher.hh
+++ b/src/line_modification.hh
@@ -19,18 +19,7 @@ struct LineModification
     LineCount diff() const { return new_line - old_line + num_added - num_removed; }
 };
 
-class LineChangeWatcher
-{
-public:
-    LineChangeWatcher (const Buffer& buffer);
-
-    std::vector<LineModification> compute_modifications();
-
-    const Buffer& buffer() const { return *m_buffer; }
-private:
-    safe_ptr<const Buffer> m_buffer;
-    size_t m_timestamp;
-};
+std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp);
 
 }
 
diff --git a/src/word_db.cc b/src/word_db.cc
index 73f6e1ad..83b362c5 100644
--- a/src/word_db.cc
+++ b/src/word_db.cc
@@ -1,6 +1,7 @@
 #include "word_db.hh"
 
 #include "utils.hh"
+#include "line_modification.hh"
 #include "utf8_iterator.hh"
 
 namespace Kakoune
@@ -49,7 +50,7 @@ static void remove_words(WordDB::WordList& wl, const std::vector<String>& words)
 }
 
 WordDB::WordDB(const Buffer& buffer)
-    : m_change_watcher{buffer}
+    : m_buffer{&buffer}, m_timestamp{buffer.timestamp()}
 {
     m_line_to_words.reserve((int)buffer.line_count());
     for (auto line = 0_line, end = buffer.line_count(); line < end; ++line)
@@ -61,11 +62,14 @@ WordDB::WordDB(const Buffer& buffer)
 
 void WordDB::update_db()
 {
-    auto modifs = m_change_watcher.compute_modifications();
+    auto& buffer = *m_buffer;
+
+    auto modifs = compute_line_modifications(buffer, m_timestamp);
+    m_timestamp = buffer.timestamp();
+
     if (modifs.empty())
         return;
 
-    auto& buffer = m_change_watcher.buffer();
 
     LineToWords new_lines;
     new_lines.reserve((int)buffer.line_count());
diff --git a/src/word_db.hh b/src/word_db.hh
index 950cc05d..2349a618 100644
--- a/src/word_db.hh
+++ b/src/word_db.hh
@@ -2,7 +2,6 @@
 #define word_db_hh_INCLUDED
 
 #include "buffer.hh"
-#include "line_change_watcher.hh"
 
 #include <map>
 
@@ -26,7 +25,8 @@ private:
 
     void update_db();
 
-    LineChangeWatcher m_change_watcher;
+    safe_ptr<const Buffer> m_buffer;
+    size_t m_timestamp;
     WordList m_words;
     LineToWords m_line_to_words;
 };

From e86e5b1b81253b0e6fa3fb3fb23070b4020ad36b Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 14 May 2014 22:16:51 +0100
Subject: [PATCH 16/53] Fix gdb pretty printer

---
 gdb/kakoune.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gdb/kakoune.py b/gdb/kakoune.py
index 7486a7fa..2192d52f 100644
--- a/gdb/kakoune.py
+++ b/gdb/kakoune.py
@@ -105,8 +105,8 @@ def build_pretty_printer():
     pp = gdb.printing.RegexpCollectionPrettyPrinter("kakoune")
     pp.add_printer('memoryview',     '^Kakoune::memoryview<.*>$',    MemoryView)
     pp.add_printer('LineAndColumn',  '^Kakoune::LineAndColumn<.*>$', LineAndColumn)
-    pp.add_printer('BufferCoord',    '^Kakoune::BufferCoord$',       LineAndColumn)
-    pp.add_printer('DisplayCoord',   '^Kakoune::DisplayCoord$',      LineAndColumn)
+    pp.add_printer('ByteCoord',      '^Kakoune::ByteCoord$',         LineAndColumn)
+    pp.add_printer('CharCoord',      '^Kakoune::CharCoord$',         LineAndColumn)
     pp.add_printer('BufferIterator', '^Kakoune::BufferIterator$',    BufferIterator)
     pp.add_printer('String',         '^Kakoune::String$',            String)
     pp.add_printer('Option',         '^Kakoune::Option$',            Option)

From 079d34b82a3690f28de3d33102eda4bb214ad13f Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 17 May 2014 12:13:49 +0100
Subject: [PATCH 17/53] Minor cleanup in SelectionList methods

---
 src/normal.cc    | 4 ++--
 src/selection.hh | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index ff38c29d..0e2d3b38 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -79,7 +79,7 @@ void insert(Buffer& buffer, SelectionList& selections, const String& str)
         }
     }
     if (mode == InsertMode::Replace)
-        selections.set_timestamp(buffer.timestamp());
+        selections.update_timestamp();
     else
         selections.update();
     selections.avoid_eol();
@@ -108,7 +108,7 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
         }
     }
     if (mode == InsertMode::Replace)
-        selections.set_timestamp(buffer.timestamp());
+        selections.update_timestamp();
     else
         selections.update();
     selections.avoid_eol();
diff --git a/src/selection.hh b/src/selection.hh
index 5f0ce459..cd60f817 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -86,6 +86,7 @@ struct SelectionList
         m_selections = std::move(list);
         m_main = size()-1;
         sort_and_merge_overlapping();
+        update_timestamp();
         check_invariant();
         return *this;
     }
@@ -115,7 +116,6 @@ struct SelectionList
     }
 
     size_t size() const { return m_selections.size(); }
-    bool empty() const { return m_selections.empty(); }
 
     bool operator==(const SelectionList& other) const { return m_buffer == other.m_buffer and m_selections == other.m_selections; }
     bool operator!=(const SelectionList& other) const { return !((*this) == other); }
@@ -149,7 +149,7 @@ struct SelectionList
     const Buffer& buffer() const { return *m_buffer; }
 
     size_t timestamp() const { return m_timestamp; }
-    void set_timestamp(size_t timestamp) { m_timestamp = timestamp; }
+    void update_timestamp() { m_timestamp = m_buffer->timestamp(); }
 
 private:
     size_t m_main = 0;

From 03e5264df44794c942a5b1d45be3acd546819d5a Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 17 May 2014 12:17:05 +0100
Subject: [PATCH 18/53] Remove per lines timestamp in Buffer

---
 src/buffer.cc       | 18 +++++++++---------
 src/buffer.hh       |  2 --
 src/buffer.inl.hh   |  5 -----
 src/highlighters.cc |  5 +++--
 4 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index 56a4350d..94ca9ce6 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -35,7 +35,7 @@ Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ m_changes.size()+1, pos, std::move(line) });
+        m_lines.emplace_back(Line{ pos, std::move(line) });
         pos += m_lines.back().length();
     }
 
@@ -88,7 +88,7 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ m_changes.size()+1, pos, std::move(line) });
+        m_lines.emplace_back(Line{ pos, std::move(line) });
         pos += m_lines.back().length();
     }
     m_fs_timestamp = fs_timestamp;
@@ -460,12 +460,12 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
         {
             if (content[i] == '\n')
             {
-                m_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start, i + 1 - start) });
+                m_lines.push_back({ offset + start, content.substr(start, i + 1 - start) });
                 start = i + 1;
             }
         }
         if (start != content.length())
-            m_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start) });
+            m_lines.push_back({ offset + start, content.substr(start) });
 
         begin = pos.column == 0 ? pos : ByteCoord{ pos.line + 1, 0 };
         end = ByteCoord{ line_count()-1, m_lines.back().length() };
@@ -487,18 +487,18 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
                 if (start == 0)
                 {
                     line_content = prefix + line_content;
-                    new_lines.push_back({ m_changes.size()+1, offset + start - prefix.length(),
+                    new_lines.push_back({ offset + start - prefix.length(),
                                           std::move(line_content) });
                 }
                 else
-                    new_lines.push_back({ m_changes.size()+1, offset + start, std::move(line_content) });
+                    new_lines.push_back({ offset + start, std::move(line_content) });
                 start = i + 1;
             }
         }
         if (start == 0)
-            new_lines.push_back({ m_changes.size()+1, offset + start - prefix.length(), prefix + content + suffix });
+            new_lines.push_back({ offset + start - prefix.length(), prefix + content + suffix });
         else if (start != content.length() or not suffix.empty())
-            new_lines.push_back({ m_changes.size()+1, offset + start, content.substr(start) + suffix });
+            new_lines.push_back({ offset + start, content.substr(start) + suffix });
 
         LineCount last_line = pos.line + new_lines.size() - 1;
 
@@ -523,7 +523,7 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
     const ByteCount length = distance(begin, end);
     String prefix = m_lines[begin.line].content.substr(0, begin.column);
     String suffix = m_lines[end.line].content.substr(end.column);
-    Line new_line = { m_changes.size()+1, m_lines[begin.line].start, prefix + suffix };
+    Line new_line = { m_lines[begin.line].start, prefix + suffix };
 
     ByteCoord next;
     if (new_line.length() != 0)
diff --git a/src/buffer.hh b/src/buffer.hh
index 3a9b0426..8be177e3 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -95,7 +95,6 @@ public:
     BufferIterator erase(BufferIterator begin, BufferIterator end);
 
     size_t         timestamp() const;
-    size_t         line_timestamp(LineCount line) const;
     time_t         fs_timestamp() const;
     void           set_fs_timestamp(time_t ts);
 
@@ -180,7 +179,6 @@ private:
 
     struct Line
     {
-        size_t    timestamp;
         ByteCount start;
         String    content;
 
diff --git a/src/buffer.inl.hh b/src/buffer.inl.hh
index 5375d993..66e82c92 100644
--- a/src/buffer.inl.hh
+++ b/src/buffer.inl.hh
@@ -100,11 +100,6 @@ inline memoryview<Buffer::Change> Buffer::changes_since(size_t timestamp) const
              m_changes.data() + m_changes.size() };
 }
 
-inline size_t Buffer::line_timestamp(LineCount line) const
-{
-    return m_lines[line].timestamp;
-}
-
 inline ByteCoord Buffer::back_coord() const
 {
     return { line_count() - 1, m_lines.back().length() - 1 };
diff --git a/src/highlighters.cc b/src/highlighters.cc
index 87c2bf9c..75a31fce 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -778,8 +778,9 @@ private:
                 erase = it->line <= prev.old_line + prev.num_removed;
                 it->line += prev.diff();
             }
-            erase = erase or (it->line >= buffer.line_count() or
-                              it->timestamp < buffer.line_timestamp(it->line));
+            if (modif_it != modifs.end() and modif_it->old_line == it->line)
+                erase = true;
+            erase = erase or (it->line >= buffer.line_count());
 
             if (not erase)
             {

From b29cae4d16077c6121e5d4cff00416fd98dfc60c Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 19 May 2014 18:59:14 +0100
Subject: [PATCH 19/53] Remove duplicated logic and fix insert in Replace mode

---
 src/normal.cc | 33 ++++-----------------------------
 1 file changed, 4 insertions(+), 29 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index 0e2d3b38..2e68f8cd 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -62,30 +62,6 @@ BufferIterator prepare_insert(Buffer& buffer, const Selection& sel)
     return {};
 }
 
-template<InsertMode mode>
-void insert(Buffer& buffer, SelectionList& selections, const String& str)
-{
-    for (auto& sel : reversed(selections))
-    {
-        auto pos = prepare_insert<mode>(buffer, sel);
-        pos = buffer.insert(pos, str);
-        if (mode == InsertMode::Replace)
-        {
-            if (pos == buffer.end())
-                --pos;
-            sel.anchor() = pos.coord();
-            sel.cursor() = str.empty() ?
-                pos.coord() : (pos + str.byte_count_to(str.char_length() - 1)).coord();
-        }
-    }
-    if (mode == InsertMode::Replace)
-        selections.update_timestamp();
-    else
-        selections.update();
-    selections.avoid_eol();
-    buffer.check_invariant();
-}
-
 template<InsertMode mode>
 void insert(Buffer& buffer, SelectionList& selections, memoryview<String> strings)
 {
@@ -102,16 +78,15 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
         {
              if (pos == buffer.end())
                  --pos;
+            selections.update();
             sel.anchor() = pos.coord();
             sel.cursor() = (str.empty() ?
                 pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
         }
     }
-    if (mode == InsertMode::Replace)
-        selections.update_timestamp();
-    else
-        selections.update();
+    selections.update();
     selections.avoid_eol();
+    selections.check_invariant();
     buffer.check_invariant();
 }
 
@@ -788,7 +763,7 @@ void join_select_spaces(Context& context, int)
         return;
     context.selections() = selections;
     ScopedEdition edition(context);
-    insert<InsertMode::Replace>(buffer, context.selections(), " ");
+    insert<InsertMode::Replace>(buffer, context.selections(), " "_str);
 }
 
 void join(Context& context, int param)

From 2c52b8bca69ebe8f1e762ab185a3fa40c0b3ecbf Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Tue, 20 May 2014 20:33:38 +0100
Subject: [PATCH 20/53] Add initial (and probably buggy) compute_modifications
 code

compute_modifications compiles a list of buffer change into
a list of Modifications that can be used for updating BufferCoord
---
 src/modification.cc | 128 ++++++++++++++++++++++++++++++++++++++++++++
 src/modification.hh |  88 ++++++++++++++++++++++++++++++
 src/selection.cc    |  28 ++++++++--
 src/unit_tests.cc   |  66 +++++++++++++++++++++++
 4 files changed, 305 insertions(+), 5 deletions(-)
 create mode 100644 src/modification.cc
 create mode 100644 src/modification.hh

diff --git a/src/modification.cc b/src/modification.cc
new file mode 100644
index 00000000..b5e91c1f
--- /dev/null
+++ b/src/modification.cc
@@ -0,0 +1,128 @@
+#include "modification.hh"
+
+#include "buffer.hh"
+
+namespace Kakoune
+{
+
+namespace
+{
+
+ByteCount change_added_column(const Buffer::Change& change)
+{
+    kak_assert(change.type == Buffer::Change::Insert);
+    if (change.begin.line == change.end.line)
+        return change.end.column - change.begin.column;
+    else
+        return change.end.column;
+}
+
+}
+
+std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes)
+{
+    std::vector<Modification> res;
+    for (auto& change : changes)
+    {
+        auto pos = std::upper_bound(res.begin(), res.end(), change.begin,
+                                    [](const ByteCoord& l, const Modification& c)
+                                    { return l < c.new_coord; });
+
+        if (pos != res.begin())
+        {
+            auto& prev = *(pos-1);
+            if (change.begin <= prev.added_end())
+                --pos;
+            else
+                pos = res.insert(pos, {prev.get_old_coord(change.begin), change.begin, {}, {}});
+        }
+        else
+            pos = res.insert(pos, {change.begin, change.begin, {}, {}});
+
+        auto& modif = *pos;
+        auto next = pos + 1;
+        if (change.type == Buffer::Change::Insert)
+        {
+            const LineCount last_line = modif.new_coord.line + modif.num_added.line;
+
+            ByteCoord num_added = { change.end.line - change.begin.line, 0 };
+
+            modif.num_added.line += num_added.line;
+
+            if (change.begin.line == last_line)
+            {
+                if (change.end.line == change.begin.line)
+                    num_added.column = change.end.column - change.begin.column;
+                else
+                    num_added.column = change.end.column - modif.num_added.column;
+
+                modif.num_added.column += num_added.column;
+                kak_assert(modif.num_added.column >= 0);
+            }
+
+            for (auto it = next; it != res.end(); ++it)
+            {
+                if (it->new_coord.line == change.begin.line and it->num_added.line == 0)
+                    it->new_coord.column += num_added.column;
+
+                it->new_coord.line += num_added.line;
+            }
+        }
+        else
+        {
+            ByteCoord num_removed = { change.end.line - change.begin.line, 0 };
+            if (num_removed.line != 0)
+                num_removed.column = change.end.column;
+            else
+                num_removed.column = change.end.column - change.begin.column;
+
+            auto delend = std::upper_bound(next, res.end(), change.end,
+                                           [](const ByteCoord& l, const Modification& c)
+                                           { return l < c.new_coord; });
+
+            for (auto it = next; it != delend; ++it)
+            {
+                {
+                    LineCount removed_from_it = (change.begin.line + num_removed.line - it->new_coord.line);
+                    modif.num_removed.line += it->num_removed.line - std::min(removed_from_it, it->num_added.line);
+                    modif.num_added.line += std::max(0_line, it->num_added.line - removed_from_it);
+                }
+
+                if (it->new_coord.line == change.end.line)
+                {
+                    ByteCount removed_from_it = num_removed.column - it->new_coord.column;
+                    modif.num_removed.column += it->num_removed.column - std::min(removed_from_it, it->num_added.column);
+                    modif.num_added.column += std::max(0_byte, it->num_added.column - removed_from_it);
+                }
+            }
+            next = res.erase(next, delend);
+
+            ByteCoord num_added_after_pos = { modif.new_coord.line + modif.num_added.line - change.begin.line, 0 };
+            if (change.begin.line == modif.new_coord.line + modif.num_added.line)
+            {
+                if (modif.num_added.line == 0)
+                    num_added_after_pos.column = modif.new_coord.column + modif.num_added.column - change.begin.column;
+                else
+                    num_added_after_pos.column = modif.num_added.column - change.begin.column;
+            }
+            ByteCoord num_removed_from_added = std::min(num_removed, num_added_after_pos);
+            modif.num_added -= num_removed_from_added;
+            modif.num_removed += num_removed - num_removed_from_added;
+
+            for (auto it = next; it != res.end(); ++it)
+            {
+                if (it->new_coord.line == change.end.line and it->num_added.line == 0)
+                    it->new_coord.column -= num_removed.column;
+                it->new_coord.line -= num_removed.line;
+            }
+        }
+    }
+    return res;
+}
+
+std::vector<Modification> compute_modifications(const Buffer& buffer, size_t timestamp)
+{
+    return compute_modifications(buffer.changes_since(timestamp));
+}
+
+}
diff --git a/src/modification.hh b/src/modification.hh
new file mode 100644
index 00000000..103a7520
--- /dev/null
+++ b/src/modification.hh
@@ -0,0 +1,88 @@
+#ifndef modification_hh_INCLUDED
+#define modification_hh_INCLUDED
+
+#include "coord.hh"
+#include "utils.hh"
+#include "buffer.hh"
+
+namespace Kakoune
+{
+
+struct Modification
+{
+    ByteCoord old_coord;
+    ByteCoord new_coord;
+    ByteCoord num_removed;
+    ByteCoord num_added;
+
+    ByteCoord added_end() const
+    {
+        if (num_added.line)
+            return { new_coord.line + num_added.line, num_added.column };
+        else
+            return { new_coord.line, new_coord.column + num_added.column };
+    }
+
+    ByteCoord get_old_coord(ByteCoord coord) const
+    {
+        if (coord.line == new_coord.line)
+        {
+            if (num_added.line == 0)
+                coord.column -= new_coord.column - old_coord.column + num_added.column - num_removed.column;
+            else
+                coord.column -= num_added.column - num_removed.column;
+        }
+        coord.line -= new_coord.line - old_coord.line + num_added.line - num_removed.line;
+        return coord;
+    }
+
+    ByteCoord get_new_coord(ByteCoord coord, bool& deleted) const
+    {
+        deleted = false;
+        if (coord < old_coord)
+            return coord;
+
+        // apply remove
+        if (coord.line < old_coord.line + num_removed.line or
+            (coord.line == old_coord.line + num_removed.line and
+             coord.column < old_coord.column + num_removed.column))
+        {
+            deleted = true;
+            coord = old_coord;
+        }
+        else if (coord.line == old_coord.line + num_removed.line)
+        {
+            coord.line = old_coord.line;
+            coord.column -= num_removed.column;
+        }
+
+        // apply move
+        coord.line += new_coord.line - old_coord.line;
+        coord.column += new_coord.column - old_coord.column;
+
+        // apply add
+        if (coord.line == new_coord.line)
+        {
+            if (num_added.line == 0)
+                coord.column += num_added.column;
+            else
+                coord.column += num_added.column - new_coord.column;
+        }
+        coord.line += num_added.line;
+
+        return coord;
+    }
+
+    ByteCoord get_new_coord(ByteCoord coord) const
+    {
+        bool dummy;
+        return get_new_coord(coord, dummy);
+    }
+};
+
+std::vector<Modification> compute_modifications(const Buffer& buffer, size_t timestamp);
+std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes);
+
+}
+
+#endif // modification_hh_INCLUDED
diff --git a/src/selection.cc b/src/selection.cc
index 1e8356ab..6b00dc54 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -1,6 +1,7 @@
 #include "selection.hh"
 
 #include "utf8.hh"
+#include "modification.hh"
 
 namespace Kakoune
 {
@@ -132,17 +133,34 @@ void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end,
     on_buffer_change<UpdateErase>(sels, begin, end, at_end, end.line);
 }
 
+static ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos)
+{
+    auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
+                                     [](const ByteCoord& c, const Modification& m)
+                                     { return c < m.old_coord; });
+    if (modif_it != modifs.begin())
+    {
+        auto& prev = *(modif_it-1);
+        return prev.get_new_coord(pos);
+    }
+    return pos;
+}
+
 void SelectionList::update()
 {
     if (m_timestamp == m_buffer->timestamp())
         return;
 
-    for (auto& change : m_buffer->changes_since(m_timestamp))
+    auto modifs = compute_modifications(*m_buffer, m_timestamp);
+    for (auto& sel : m_selections)
     {
-        if (change.type == Buffer::Change::Insert)
-            update_insert(m_selections, change.begin, change.end, change.at_end);
-        else
-            update_erase(m_selections, change.begin, change.end, change.at_end);
+        auto anchor = update_pos(modifs, sel.anchor());
+        kak_assert(m_buffer->is_valid(anchor));
+        sel.anchor() = anchor;
+
+        auto cursor = update_pos(modifs, sel.cursor());
+        kak_assert(m_buffer->is_valid(cursor));
+        sel.cursor() = cursor;
     }
 
     check_invariant();
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index 0bfa341b..fa21b736 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -4,6 +4,8 @@
 #include "selectors.hh"
 #include "word_db.hh"
 
+#include "modification.hh"
+
 using namespace Kakoune;
 
 void test_buffer()
@@ -139,6 +141,69 @@ void test_keys()
     kak_assert(keys == parsed_keys);
 }
 
+void test_modification()
+{
+    {
+        Modification modif = { {5, 10}, {5, 10}, {0, 0}, {4, 17} };
+        auto pos = modif.get_new_coord({5, 10});
+        kak_assert(pos == ByteCoord{9 COMMA 17});
+    }
+    {
+        Modification modif = { {7, 10}, {7, 10}, {0, 5}, {0, 0} };
+        auto pos = modif.get_new_coord({7, 10});
+        kak_assert(pos == ByteCoord{7 COMMA 10});
+    }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Insert, {1, 0}, {5, 161}, false },
+            { Buffer::Change::Insert, {5, 161}, {30, 0}, false },
+            { Buffer::Change::Insert, {30, 0}, {35, 0}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 1);
+        auto& modif = modifs[0];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 0});
+        kak_assert(modif.new_coord == ByteCoord{1 COMMA 0});
+        kak_assert(modif.num_added == ByteCoord{34 COMMA 0});
+        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
+    }
+
+    Buffer buffer("test", Buffer::Flags::None,
+                  { "tchou mutch\n",
+                    "tchou kanaky tchou\n",
+                    "\n",
+                    "tchaa tchaa\n",
+                    "allo\n"});
+
+    size_t timestamp = buffer.timestamp();
+
+    buffer.erase(buffer.iterator_at({0,0}), buffer.iterator_at({3,0}));
+    buffer.insert(buffer.iterator_at({0,0}), "youuhou\nniahaha");
+
+    buffer.insert(buffer.iterator_at({2,4}), "yeehaah\n");
+
+    auto modifs = compute_modifications(buffer, timestamp);
+    kak_assert(modifs.size() == 2);
+    {
+        auto& modif = modifs[0];
+        kak_assert(modif.old_coord == ByteCoord{0 COMMA 0});
+        kak_assert(modif.new_coord == ByteCoord{0 COMMA 0});
+        kak_assert(modif.num_added == ByteCoord{1 COMMA 7});
+        kak_assert(modif.num_removed == ByteCoord{3 COMMA 0});
+        bool deleted;
+        auto new_coord = modif.get_new_coord({1, 10}, deleted);
+        kak_assert(new_coord == ByteCoord{1 COMMA 7});
+        kak_assert(deleted);
+    }
+    {
+        auto& modif = modifs[1];
+        kak_assert(modif.old_coord == ByteCoord{4 COMMA 4});
+        kak_assert(modif.new_coord == ByteCoord{2 COMMA 4});
+        kak_assert(modif.num_added == ByteCoord{1 COMMA 0});
+        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
+    }
+}
+
 void run_unit_tests()
 {
     test_utf8();
@@ -146,5 +211,6 @@ void run_unit_tests()
     test_keys();
     test_buffer();
     test_undo_group_optimizer();
+    test_modification();
     test_word_db();
 }

From 8f45623f98f187667b3842d432b1102b58e39037 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Tue, 20 May 2014 20:39:38 +0100
Subject: [PATCH 21/53] update Modification for WordDB

---
 src/word_db.cc | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/word_db.cc b/src/word_db.cc
index 83b362c5..44a57e2f 100644
--- a/src/word_db.cc
+++ b/src/word_db.cc
@@ -1,7 +1,7 @@
 #include "word_db.hh"
 
 #include "utils.hh"
-#include "line_modification.hh"
+#include "modification.hh"
 #include "utf8_iterator.hh"
 
 namespace Kakoune
@@ -64,7 +64,7 @@ void WordDB::update_db()
 {
     auto& buffer = *m_buffer;
 
-    auto modifs = compute_line_modifications(buffer, m_timestamp);
+    auto modifs = compute_modifications(buffer, m_timestamp);
     m_timestamp = buffer.timestamp();
 
     if (modifs.empty())
@@ -77,22 +77,22 @@ void WordDB::update_db()
     auto old_line = 0_line;
     for (auto& modif : modifs)
     {
-        kak_assert(0_line <= modif.new_line and modif.new_line < buffer.line_count());
-        kak_assert(old_line <= modif.old_line);
-        while (old_line < modif.old_line)
+        kak_assert(0_line <= modif.new_coord.line and
+                   modif.new_coord.line < buffer.line_count());
+
+        // copy unchanged lines between last modification and this one
+        while (old_line < modif.old_coord.line)
             new_lines.push_back(std::move(m_line_to_words[(int)old_line++]));
 
-        kak_assert((int)new_lines.size() == (int)modif.new_line);
-
-        while (old_line <= modif.old_line + modif.num_removed)
-        {
-            kak_assert(old_line < m_line_to_words.size());
+        // remove words from removed lines
+        while (old_line <= modif.old_coord.line + modif.num_removed.line
+               and old_line < m_line_to_words.size())
             remove_words(m_words, m_line_to_words[(int)old_line++]);
-        }
 
-        for (auto l = 0_line; l <= modif.num_added; ++l)
+        // add words from new lines
+        for (auto l = 0_line; l <= modif.num_added.line; ++l)
         {
-            new_lines.push_back(get_words(buffer[modif.new_line + l]));
+            new_lines.push_back(get_words(buffer[modif.new_coord.line + l]));
             add_words(m_words, new_lines.back());
         }
     }

From aa64851de622921751741d39092e7cf14fe28649 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 21 May 2014 23:32:08 +0100
Subject: [PATCH 22/53] Use Modification for region highlighter

---
 src/highlighters.cc | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/highlighters.cc b/src/highlighters.cc
index 75a31fce..19d7ac3f 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -5,7 +5,7 @@
 #include "color_registry.hh"
 #include "context.hh"
 #include "display_buffer.hh"
-#include "line_modification.hh"
+#include "modification.hh"
 #include "option_types.hh"
 #include "register_manager.hh"
 #include "string.hh"
@@ -720,7 +720,7 @@ private:
         }
         else
         {
-            auto modifs = compute_line_modifications(buffer, cache.timestamp);
+            auto modifs = compute_modifications(buffer, cache.timestamp);
             update_matches(buffer, modifs, cache.begin_matches, m_begin);
             update_matches(buffer, modifs, cache.end_matches, m_end);
         }
@@ -761,26 +761,28 @@ private:
         }
     }
 
-    void update_matches(const Buffer& buffer, memoryview<LineModification> modifs, MatchList& matches, const Regex& regex)
+    void update_matches(const Buffer& buffer, memoryview<Modification> modifs, MatchList& matches, const Regex& regex)
     {
         const size_t buf_timestamp = buffer.timestamp();
         // remove out of date matches and update line for others
         auto ins_pos = matches.begin();
         for (auto it = ins_pos; it != matches.end(); ++it)
         {
-            auto modif_it = std::lower_bound(modifs.begin(), modifs.end(), it->line,
-                                             [](const LineModification& c, const LineCount& l)
-                                             { return c.old_line < l; });
+            const ByteCoord pos{ it->line, it->begin };
+            auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
+                                             [](const ByteCoord& c, const Modification& m)
+                                             { return c < m.old_coord; });
             bool erase = false;
             if (modif_it != modifs.begin())
             {
                 auto& prev = *(modif_it-1);
-                erase = it->line <= prev.old_line + prev.num_removed;
-                it->line += prev.diff();
+                erase = it->line <= prev.old_coord.line + prev.num_removed.line;
+                it->line += prev.new_coord.line - prev.old_coord.line +
+                            prev.num_added.line - prev.num_removed.line;
             }
-            if (modif_it != modifs.end() and modif_it->old_line == it->line)
+            if (modif_it != modifs.end() and modif_it->new_coord.line == it->line)
                 erase = true;
-            erase = erase or (it->line >= buffer.line_count());
+            kak_assert(it->line < buffer.line_count());
 
             if (not erase)
             {
@@ -799,19 +801,24 @@ private:
         size_t pivot = matches.size();
 
         // try to find new matches in each updated lines
+        LineCount last_line = -1;
         for (auto& modif : modifs)
         {
-            for (auto line = modif.new_line; line < modif.new_line + modif.num_added+1; ++line)
+            for (auto line = std::max(last_line + 1, modif.new_coord.line);
+                 line <= modif.new_coord.line + modif.num_added.line;
+                 ++line)
             {
                 kak_assert(line < buffer.line_count());
                 auto& l = buffer[line];
-                for (boost::regex_iterator<String::const_iterator> it{l.begin(), l.end(), regex}, end{}; it != end; ++it)
+                using RegexIt = boost::regex_iterator<String::const_iterator>;
+                for (RegexIt it{l.begin(), l.end(), regex}, end; it != end; ++it)
                 {
                     ByteCount b = (int)((*it)[0].first - l.begin());
                     ByteCount e = (int)((*it)[0].second - l.begin());
                     matches.push_back({ buf_timestamp, line, b, e });
                 }
             }
+            last_line = modif.new_coord.line + modif.num_added.line;
         }
         std::inplace_merge(matches.begin(), matches.begin() + pivot, matches.end(),
                            compare_matches_begin);

From a7540962cc90266f4f46858184b89f048364f9b2 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 21 May 2014 23:33:35 +0100
Subject: [PATCH 23/53] Remove line modification, replaced by modification

---
 src/line_modification.cc | 105 ---------------------------------------
 src/line_modification.hh |  26 ----------
 2 files changed, 131 deletions(-)
 delete mode 100644 src/line_modification.cc
 delete mode 100644 src/line_modification.hh

diff --git a/src/line_modification.cc b/src/line_modification.cc
deleted file mode 100644
index 5da287fc..00000000
--- a/src/line_modification.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "line_modification.hh"
-
-#include "buffer.hh"
-
-namespace Kakoune
-{
-
-namespace
-{
-
-struct LineChange
-{
-    LineChange(const Buffer::Change& change)
-    {
-        ByteCoord begin = change.begin;
-        ByteCoord end = change.end;
-        if (change.type == Buffer::Change::Insert)
-        {
-            if (change.at_end and begin != ByteCoord{0,0})
-            {
-                kak_assert(begin.column == 0);
-                --begin.line;
-            }
-            pos = begin.line;
-            num = end.line - begin.line;
-        }
-        else
-        {
-            if (change.at_end and begin != ByteCoord{0,0})
-            {
-                kak_assert(begin.column == 0);
-                --begin.line;
-            }
-            pos = begin.line;
-            num = begin.line - end.line;
-        }
-    }
-
-    LineCount pos;
-    LineCount num;
-};
-
-}
-
-std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp)
-{
-    std::vector<LineModification> res;
-    for (auto& buf_change : buffer.changes_since(timestamp))
-    {
-        const LineChange change(buf_change);
-
-        auto pos = std::upper_bound(res.begin(), res.end(), change.pos,
-                                    [](const LineCount& l, const LineModification& c)
-                                    { return l < c.new_line; });
-
-        if (pos != res.begin())
-        {
-            auto& prev = *(pos-1);
-            if (change.pos <= prev.new_line + prev.num_added)
-                --pos;
-            else
-                pos = res.insert(pos, {change.pos - prev.diff(), change.pos, 0, 0});
-        }
-        else
-            pos = res.insert(pos, {change.pos, change.pos, 0, 0});
-
-        auto& modif = *pos;
-        auto next = pos + 1;
-        if (change.num > 0)
-        {
-            modif.num_added += change.num;
-            for (auto it = next; it != res.end(); ++it)
-                it->new_line += change.num;
-        }
-        if (change.num < 0)
-        {
-            const LineCount num_removed = -change.num;
-
-            auto delend = std::upper_bound(next, res.end(), change.pos + num_removed,
-                                           [](const LineCount& l, const LineModification& c)
-                                           { return l < c.new_line; });
-
-            for (auto it = next; it != delend; ++it)
-            {
-                LineCount removed_from_it = (change.pos + num_removed - it->new_line);
-                modif.num_removed += it->num_removed - std::min(removed_from_it, it->num_added);
-                modif.num_added += std::max(0_line, it->num_added - removed_from_it);
-            }
-            next = res.erase(next, delend);
-
-            const LineCount num_added_after_pos =
-                modif.new_line + modif.num_added - change.pos;
-            const LineCount num_removed_from_added =
-                std::min(num_removed, num_added_after_pos);
-            modif.num_added -= num_removed_from_added;
-            modif.num_removed += num_removed - num_removed_from_added;
-
-            for (auto it = next; it != res.end(); ++it)
-                it->new_line -= num_removed;
-        }
-    }
-    return res;
-}
-
-}
diff --git a/src/line_modification.hh b/src/line_modification.hh
deleted file mode 100644
index 3cd2d669..00000000
--- a/src/line_modification.hh
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef line_change_watcher_hh_INCLUDED
-#define line_change_watcher_hh_INCLUDED
-
-#include "units.hh"
-#include "utils.hh"
-
-namespace Kakoune
-{
-
-class Buffer;
-
-struct LineModification
-{
-    LineCount old_line; // line position in the old buffer
-    LineCount new_line; // new line position
-    LineCount num_removed; // number of lines removed after this one
-    LineCount num_added; // number of lines added after this one
-
-    LineCount diff() const { return new_line - old_line + num_added - num_removed; }
-};
-
-std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp);
-
-}
-
-#endif // line_change_watcher_hh_INCLUDED

From 695c85f4513241c55296a37d2cf6cf0cd25dbecf Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Thu, 22 May 2014 09:52:22 +0100
Subject: [PATCH 24/53] Fix, cleanup and refactor compute_modifications

---
 src/modification.cc | 115 ++++++++++++++++++++++++++++++++++++++------
 src/modification.hh |  69 +++-----------------------
 src/selection.cc    |  14 +-----
 src/unit_tests.cc   |  41 ++++++++++++++--
 4 files changed, 147 insertions(+), 92 deletions(-)

diff --git a/src/modification.cc b/src/modification.cc
index b5e91c1f..2539ea3a 100644
--- a/src/modification.cc
+++ b/src/modification.cc
@@ -19,6 +19,64 @@ ByteCount change_added_column(const Buffer::Change& change)
 
 }
 
+ByteCoord Modification::added_end() const
+{
+    if (num_added.line)
+        return { new_coord.line + num_added.line, num_added.column };
+    else
+        return { new_coord.line, new_coord.column + num_added.column };
+}
+
+ByteCoord Modification::removed_end() const
+{
+    if (num_removed.line)
+        return { old_coord.line + num_removed.line, num_removed.column };
+    else
+        return { old_coord.line, old_coord.column + num_removed.column };
+}
+
+ByteCoord Modification::get_old_coord(ByteCoord coord) const
+{
+    Modification inverse = { new_coord, old_coord, num_added, num_removed };
+    return inverse.get_new_coord(coord);
+}
+
+ByteCoord Modification::get_new_coord(ByteCoord coord) const
+{
+    if (coord < old_coord)
+        return coord;
+
+    // apply remove
+    if (coord < removed_end())
+        coord = old_coord;
+    else if (coord.line == old_coord.line + num_removed.line)
+    {
+        coord.line = old_coord.line;
+        if (num_removed.line != 0)
+            coord.column += old_coord.column;
+        coord.column -= num_removed.column;
+    }
+    else
+        coord.line -= num_removed.line;
+
+    // apply move
+    coord.line += new_coord.line - old_coord.line;
+    if (coord.line == new_coord.line)
+        coord.column += new_coord.column - old_coord.column;
+
+    // apply add
+    if (coord.line == new_coord.line)
+    {
+        if (num_added.line == 0)
+            coord.column += num_added.column;
+        else
+            coord.column += num_added.column - new_coord.column;
+    }
+    coord.line += num_added.line;
+
+    return coord;
+}
+
 std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes)
 {
     std::vector<Modification> res;
@@ -45,27 +103,27 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
         {
             const LineCount last_line = modif.new_coord.line + modif.num_added.line;
 
-            ByteCoord num_added = { change.end.line - change.begin.line, 0 };
-
-            modif.num_added.line += num_added.line;
+            modif.num_added.line += change.end.line - change.begin.line;
 
             if (change.begin.line == last_line)
             {
                 if (change.end.line == change.begin.line)
-                    num_added.column = change.end.column - change.begin.column;
+                    modif.num_added.column += change.end.column - change.begin.column;
                 else
-                    num_added.column = change.end.column - modif.num_added.column;
-
-                modif.num_added.column += num_added.column;
+                    modif.num_added.column = change.end.column;
                 kak_assert(modif.num_added.column >= 0);
             }
 
             for (auto it = next; it != res.end(); ++it)
             {
-                if (it->new_coord.line == change.begin.line and it->num_added.line == 0)
-                    it->new_coord.column += num_added.column;
+                if (it->new_coord.line == change.begin.line)
+                    it->new_coord.column += change.end.column - change.begin.column;
+                it->new_coord.line += change.end.line - change.begin.line;
 
-                it->new_coord.line += num_added.line;
+#ifdef KAK_DEBUG
+                auto ref_new_coord = (it-1)->get_new_coord(it->old_coord);
+                kak_assert(it->new_coord == ref_new_coord);
+#endif
             }
         }
         else
@@ -83,7 +141,7 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
             for (auto it = next; it != delend; ++it)
             {
                 {
-                    LineCount removed_from_it = (change.begin.line + num_removed.line - it->new_coord.line);
+                    LineCount removed_from_it = change.end.line - it->new_coord.line;
                     modif.num_removed.line += it->num_removed.line - std::min(removed_from_it, it->num_added.line);
                     modif.num_added.line += std::max(0_line, it->num_added.line - removed_from_it);
                 }
@@ -111,12 +169,28 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
 
             for (auto it = next; it != res.end(); ++it)
             {
-                if (it->new_coord.line == change.end.line and it->num_added.line == 0)
-                    it->new_coord.column -= num_removed.column;
-                it->new_coord.line -= num_removed.line;
+                if (it->new_coord.line == change.end.line)
+                    it->new_coord.column += change.begin.column - change.end.column;
+                it->new_coord.line += change.begin.line - change.end.line;
+
+#ifdef KAK_DEBUG
+                auto ref_new_coord = (it-1)->get_new_coord(it->old_coord);
+                kak_assert(it->new_coord == ref_new_coord);
+#endif
             }
         }
     }
+
+#ifdef KAK_DEBUG
+    for (size_t i = 0; i+1 < res.size(); ++i)
+    {
+        auto old_coord = res[i].get_old_coord(res[i+1].new_coord);
+        kak_assert(res[i+1].old_coord == old_coord);
+        auto new_coord = res[i].get_new_coord(res[i+1].old_coord);
+        kak_assert(res[i+1].new_coord == new_coord);
+    }
+#endif
+
     return res;
 }
 
@@ -125,4 +199,17 @@ std::vector<Modification> compute_modifications(const Buffer& buffer, size_t tim
     return compute_modifications(buffer.changes_since(timestamp));
 }
 
+ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos)
+{
+    auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
+                                     [](const ByteCoord& c, const Modification& m)
+                                     { return c < m.old_coord; });
+    if (modif_it != modifs.begin())
+    {
+        auto& prev = *(modif_it-1);
+        return prev.get_new_coord(pos);
+    }
+    return pos;
+}
+
 }
diff --git a/src/modification.hh b/src/modification.hh
index 103a7520..2b972a84 100644
--- a/src/modification.hh
+++ b/src/modification.hh
@@ -15,74 +15,19 @@ struct Modification
     ByteCoord num_removed;
     ByteCoord num_added;
 
-    ByteCoord added_end() const
-    {
-        if (num_added.line)
-            return { new_coord.line + num_added.line, num_added.column };
-        else
-            return { new_coord.line, new_coord.column + num_added.column };
-    }
+    ByteCoord added_end() const;
+    ByteCoord removed_end() const;
 
-    ByteCoord get_old_coord(ByteCoord coord) const
-    {
-        if (coord.line == new_coord.line)
-        {
-            if (num_added.line == 0)
-                coord.column -= new_coord.column - old_coord.column + num_added.column - num_removed.column;
-            else
-                coord.column -= num_added.column - num_removed.column;
-        }
-        coord.line -= new_coord.line - old_coord.line + num_added.line - num_removed.line;
-        return coord;
-    }
-
-    ByteCoord get_new_coord(ByteCoord coord, bool& deleted) const
-    {
-        deleted = false;
-        if (coord < old_coord)
-            return coord;
-
-        // apply remove
-        if (coord.line < old_coord.line + num_removed.line or
-            (coord.line == old_coord.line + num_removed.line and
-             coord.column < old_coord.column + num_removed.column))
-        {
-            deleted = true;
-            coord = old_coord;
-        }
-        else if (coord.line == old_coord.line + num_removed.line)
-        {
-            coord.line = old_coord.line;
-            coord.column -= num_removed.column;
-        }
-
-        // apply move
-        coord.line += new_coord.line - old_coord.line;
-        coord.column += new_coord.column - old_coord.column;
-
-        // apply add
-        if (coord.line == new_coord.line)
-        {
-            if (num_added.line == 0)
-                coord.column += num_added.column;
-            else
-                coord.column += num_added.column - new_coord.column;
-        }
-        coord.line += num_added.line;
-
-        return coord;
-    }
-
-    ByteCoord get_new_coord(ByteCoord coord) const
-    {
-        bool dummy;
-        return get_new_coord(coord, dummy);
-    }
+    ByteCoord get_old_coord(ByteCoord coord) const;
+    ByteCoord get_new_coord(ByteCoord coord) const;
 };
 
 std::vector<Modification> compute_modifications(const Buffer& buffer, size_t timestamp);
 std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes);
 
+ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos);
+
+
 }
 
 #endif // modification_hh_INCLUDED
diff --git a/src/selection.cc b/src/selection.cc
index 6b00dc54..f2126975 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -133,19 +133,6 @@ void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end,
     on_buffer_change<UpdateErase>(sels, begin, end, at_end, end.line);
 }
 
-static ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos)
-{
-    auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
-                                     [](const ByteCoord& c, const Modification& m)
-                                     { return c < m.old_coord; });
-    if (modif_it != modifs.begin())
-    {
-        auto& prev = *(modif_it-1);
-        return prev.get_new_coord(pos);
-    }
-    return pos;
-}
-
 void SelectionList::update()
 {
     if (m_timestamp == m_buffer->timestamp())
@@ -163,6 +150,7 @@ void SelectionList::update()
         sel.cursor() = cursor;
     }
 
+    merge_overlapping(overlaps);
     check_invariant();
 
     m_timestamp = m_buffer->timestamp();
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index fa21b736..6bae7a80 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -153,6 +153,16 @@ void test_modification()
         auto pos = modif.get_new_coord({7, 10});
         kak_assert(pos == ByteCoord{7 COMMA 10});
     }
+    {
+        Modification modif = { {8, 0}, {8, 0}, {1, 0}, {1, 0} };
+        auto pos = modif.get_new_coord({12, 31});
+        kak_assert(pos == ByteCoord{12 COMMA 31});
+    }
+    {
+        Modification modif = { {0, 7}, {0, 8}, {0, 0}, {0, 1} };
+        auto pos = modif.get_new_coord({1, 0});
+        kak_assert(pos == ByteCoord{1 COMMA 0});
+    }
     {
         std::vector<Buffer::Change> change = {
             { Buffer::Change::Insert, {1, 0}, {5, 161}, false },
@@ -167,6 +177,33 @@ void test_modification()
         kak_assert(modif.num_added == ByteCoord{34 COMMA 0});
         kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
     }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Insert, {1, 20}, {2, 0}, false },
+            { Buffer::Change::Insert, {1, 10}, {2, 0}, false },
+            { Buffer::Change::Insert, {1, 0},  {2, 0}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 3);
+        auto& modif = modifs[2];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 20});
+        kak_assert(modif.new_coord == ByteCoord{3 COMMA 10});
+        kak_assert(modif.num_added == ByteCoord{1 COMMA 0});
+        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
+    }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Erase, {1, 10}, {2, 0}, false },
+            { Buffer::Change::Erase, {0, 10}, {1, 0}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 2);
+        auto& modif = modifs[1];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 10});
+        kak_assert(modif.new_coord == ByteCoord{0 COMMA 20});
+        kak_assert(modif.num_added == ByteCoord{0 COMMA 0});
+        kak_assert(modif.num_removed == ByteCoord{1 COMMA 0});
+    }
 
     Buffer buffer("test", Buffer::Flags::None,
                   { "tchou mutch\n",
@@ -190,10 +227,8 @@ void test_modification()
         kak_assert(modif.new_coord == ByteCoord{0 COMMA 0});
         kak_assert(modif.num_added == ByteCoord{1 COMMA 7});
         kak_assert(modif.num_removed == ByteCoord{3 COMMA 0});
-        bool deleted;
-        auto new_coord = modif.get_new_coord({1, 10}, deleted);
+        auto new_coord = modif.get_new_coord({1, 10});
         kak_assert(new_coord == ByteCoord{1 COMMA 7});
-        kak_assert(deleted);
     }
     {
         auto& modif = modifs[1];

From eba98ecad488c0416b0efc300c565090104d78ee Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Thu, 22 May 2014 09:52:52 +0100
Subject: [PATCH 25/53] Clamp modified coord in Selection as it could be buffer
 end

---
 src/selection.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/selection.cc b/src/selection.cc
index f2126975..176bc076 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -143,11 +143,11 @@ void SelectionList::update()
     {
         auto anchor = update_pos(modifs, sel.anchor());
         kak_assert(m_buffer->is_valid(anchor));
-        sel.anchor() = anchor;
+        sel.anchor() = m_buffer->clamp(anchor);
 
         auto cursor = update_pos(modifs, sel.cursor());
         kak_assert(m_buffer->is_valid(cursor));
-        sel.cursor() = cursor;
+        sel.cursor() = m_buffer->clamp(cursor);
     }
 
     merge_overlapping(overlaps);

From 1544a006c9cde5c3fd19ee763dd9d39ac2633f6d Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 02:12:52 +0100
Subject: [PATCH 26/53] Fix selection update in when doing a 'replace' insert

---
 src/normal.cc | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/normal.cc b/src/normal.cc
index 2e68f8cd..cc611d9f 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -17,6 +17,7 @@
 #include "user_interface.hh"
 #include "utf8_iterator.hh"
 #include "debug.hh"
+#include "modification.hh"
 
 namespace Kakoune
 {
@@ -67,6 +68,8 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
 {
     if (strings.empty())
         return;
+
+    selections.update();
     for (size_t i = 0; i < selections.size(); ++i)
     {
         size_t index = selections.size() - 1 - i;
@@ -78,10 +81,19 @@ void insert(Buffer& buffer, SelectionList& selections, memoryview<String> string
         {
              if (pos == buffer.end())
                  --pos;
-            selections.update();
             sel.anchor() = pos.coord();
             sel.cursor() = (str.empty() ?
                 pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
+
+           // update following selections
+           auto changes = compute_modifications(buffer, selections.timestamp());
+           for (size_t j = index+1; j < selections.size(); ++j)
+           {
+               auto& sel = selections[j];
+               sel.anchor() = update_pos(changes, sel.anchor());
+               sel.cursor() = update_pos(changes, sel.cursor());
+           }
+           selections.update_timestamp();
         }
     }
     selections.update();

From a6de024c1fb9b1bcc04d9cea48c10131bb2f4168 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 02:35:08 +0100
Subject: [PATCH 27/53] Fix Modification

---
 src/modification.cc |  6 ++++++
 src/unit_tests.cc   | 13 +++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/src/modification.cc b/src/modification.cc
index 2539ea3a..876463f1 100644
--- a/src/modification.cc
+++ b/src/modification.cc
@@ -165,6 +165,12 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
             }
             ByteCoord num_removed_from_added = std::min(num_removed, num_added_after_pos);
             modif.num_added -= num_removed_from_added;
+
+            if (change.begin.line == modif.new_coord.line)
+                modif.num_added.column += change.begin.column - modif.new_coord.column;
+            else
+                modif.num_added.column += change.begin.column;
+
             modif.num_removed += num_removed - num_removed_from_added;
 
             for (auto it = next; it != res.end(); ++it)
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index 6bae7a80..36c885bd 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -204,6 +204,19 @@ void test_modification()
         kak_assert(modif.num_added == ByteCoord{0 COMMA 0});
         kak_assert(modif.num_removed == ByteCoord{1 COMMA 0});
     }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Insert, {1, 10}, {2, 0}, false },
+            { Buffer::Change::Erase, {1, 20}, {2, 10}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 1);
+        auto& modif = modifs[0];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 10});
+        kak_assert(modif.new_coord == ByteCoord{1 COMMA 10});
+        kak_assert(modif.num_added == ByteCoord{0 COMMA 10});
+        kak_assert(modif.num_removed == ByteCoord{0 COMMA 10});
+    }
 
     Buffer buffer("test", Buffer::Flags::None,
                   { "tchou mutch\n",

From 0aa5c4e779f5ef28eafd745a0a24540882fbb52c Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 13:03:37 +0100
Subject: [PATCH 28/53] Still more fixes for Modification

---
 src/modification.cc | 45 ++++++++++++++++++++++++++++-----------------
 src/unit_tests.cc   | 27 +++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 17 deletions(-)

diff --git a/src/modification.cc b/src/modification.cc
index 876463f1..ba22a373 100644
--- a/src/modification.cc
+++ b/src/modification.cc
@@ -134,6 +134,9 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
             else
                 num_removed.column = change.end.column - change.begin.column;
 
+            ByteCoord num_added;
+
+            // merge modifications lying in the erased range.
             auto delend = std::upper_bound(next, res.end(), change.end,
                                            [](const ByteCoord& l, const Modification& c)
                                            { return l < c.new_coord; });
@@ -142,36 +145,44 @@ std::vector<Modification> compute_modifications(memoryview<Buffer::Change> chang
             {
                 {
                     LineCount removed_from_it = change.end.line - it->new_coord.line;
-                    modif.num_removed.line += it->num_removed.line - std::min(removed_from_it, it->num_added.line);
-                    modif.num_added.line += std::max(0_line, it->num_added.line - removed_from_it);
+                    num_removed.line += it->num_removed.line - std::min(removed_from_it, it->num_added.line);
+                    num_added.line += std::max(0_line, it->num_added.line - removed_from_it);
                 }
 
                 if (it->new_coord.line == change.end.line)
+                    num_removed.column += it->num_removed.column;
+                if (it->new_coord.line + it->num_added.line == change.end.line)
                 {
-                    ByteCount removed_from_it = num_removed.column - it->new_coord.column;
-                    modif.num_removed.column += it->num_removed.column - std::min(removed_from_it, it->num_added.column);
-                    modif.num_added.column += std::max(0_byte, it->num_added.column - removed_from_it);
+                    ByteCount removed_from_added = std::min(num_removed.column, it->num_added.column);
+                    num_added.column += std::max(0_byte, it->num_added.column - removed_from_added);
+                    num_removed.column -= removed_from_added;
                 }
+                if (it->new_coord.line == change.begin.line)
+                    num_removed.column += it->new_coord.column - change.begin.column;
             }
             next = res.erase(next, delend);
 
-            ByteCoord num_added_after_pos = { modif.new_coord.line + modif.num_added.line - change.begin.line, 0 };
-            if (change.begin.line == modif.new_coord.line + modif.num_added.line)
+            // update modification with changes
+            if (change.end.line == modif.new_coord.line + modif.num_added.line)
             {
-                if (modif.num_added.line == 0)
-                    num_added_after_pos.column = modif.new_coord.column + modif.num_added.column - change.begin.column;
-                else
-                    num_added_after_pos.column = modif.num_added.column - change.begin.column;
+                ByteCount removed_from_added = std::min(num_removed.column, modif.num_added.column);
+                modif.num_added.column = std::max(0_byte, modif.num_added.column - removed_from_added) + num_added.column;
+                modif.num_removed.column += num_removed.column - removed_from_added;
+            }
+            else if (change.end.line > modif.new_coord.line + modif.num_added.line)
+            {
+                modif.num_added.column = num_added.column;
+                modif.num_removed.column = num_removed.column;
             }
-            ByteCoord num_removed_from_added = std::min(num_removed, num_added_after_pos);
-            modif.num_added -= num_removed_from_added;
-
             if (change.begin.line == modif.new_coord.line)
                 modif.num_added.column += change.begin.column - modif.new_coord.column;
-            else
-                modif.num_added.column += change.begin.column;
 
-            modif.num_removed += num_removed - num_removed_from_added;
+            {
+                LineCount change_pos_in_modif = change.begin.line - modif.new_coord.line;
+                LineCount removed_from_added = std::min(num_removed.line, modif.num_added.line - change_pos_in_modif);
+                modif.num_added.line = std::max(0_line, modif.num_added.line - removed_from_added) + num_added.line;
+                modif.num_removed.line += num_removed.line - removed_from_added;
+            }
 
             for (auto it = next; it != res.end(); ++it)
             {
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index 36c885bd..16b6b122 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -217,6 +217,33 @@ void test_modification()
         kak_assert(modif.num_added == ByteCoord{0 COMMA 10});
         kak_assert(modif.num_removed == ByteCoord{0 COMMA 10});
     }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Insert, {1, 10}, {2, 20}, false },
+            { Buffer::Change::Erase, {1, 5}, {2, 10}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 1);
+        auto& modif = modifs[0];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 5});
+        kak_assert(modif.new_coord == ByteCoord{1 COMMA 5});
+        kak_assert(modif.num_added == ByteCoord{0 COMMA 10});
+        kak_assert(modif.num_removed == ByteCoord{0 COMMA 5});
+    }
+    {
+        std::vector<Buffer::Change> change = {
+            { Buffer::Change::Insert, {1, 10}, {2, 20}, false },
+            { Buffer::Change::Erase, {1, 5}, {2, 10}, false },
+            { Buffer::Change::Erase, {1, 10}, {2, 0}, false },
+        };
+        auto modifs = compute_modifications(change);
+        kak_assert(modifs.size() == 1);
+        auto& modif = modifs[0];
+        kak_assert(modif.old_coord == ByteCoord{1 COMMA 5});
+        kak_assert(modif.new_coord == ByteCoord{1 COMMA 5});
+        kak_assert(modif.num_added == ByteCoord{0 COMMA 5});
+        kak_assert(modif.num_removed == ByteCoord{1 COMMA 0});
+    }
 
     Buffer buffer("test", Buffer::Flags::None,
                   { "tchou mutch\n",

From 95200d1de19a6282e4784a673a3a950768e8b78b Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 14:10:27 +0100
Subject: [PATCH 29/53] Avoid buffer end line in word_db update

---
 src/word_db.cc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/word_db.cc b/src/word_db.cc
index 44a57e2f..b57b8d52 100644
--- a/src/word_db.cc
+++ b/src/word_db.cc
@@ -92,6 +92,9 @@ void WordDB::update_db()
         // add words from new lines
         for (auto l = 0_line; l <= modif.num_added.line; ++l)
         {
+            if (modif.new_coord.line + l >= buffer.line_count())
+                break;
+
             new_lines.push_back(get_words(buffer[modif.new_coord.line + l]));
             add_words(m_words, new_lines.back());
         }

From b6b646e9a225ef7c780d539d13e382505ff06328 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 17:08:01 +0100
Subject: [PATCH 30/53] Remove use of 'offset' in buffer iterators, lines are
 just String

No need to maintain line offsets anymore.
---
 src/buffer.cc           | 91 +++++++++++++++++++++--------------------
 src/buffer.hh           | 21 +++-------
 src/buffer.inl.hh       | 30 +++++++-------
 src/insert_completer.cc |  7 ++--
 src/selectors.cc        |  2 +-
 src/unit_tests.cc       |  3 ++
 6 files changed, 74 insertions(+), 80 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index 94ca9ce6..91f143c8 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -30,13 +30,11 @@ Buffer::Buffer(String name, Flags flags, std::vector<String> lines,
     if (lines.empty())
         lines.emplace_back("\n");
 
-    ByteCount pos = 0;
     m_lines.reserve(lines.size());
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ pos, std::move(line) });
-        pos += m_lines.back().length();
+        m_lines.emplace_back(std::move(line));
     }
 
     m_changes.push_back({ Change::Insert, {0,0}, line_count(), true });
@@ -83,13 +81,11 @@ void Buffer::reload(std::vector<String> lines, time_t fs_timestamp)
     if (lines.empty())
         lines.emplace_back("\n");
 
-    ByteCount pos = 0;
     m_lines.reserve(lines.size());
     for (auto& line : lines)
     {
         kak_assert(not line.empty() and line.back() == '\n');
-        m_lines.emplace_back(Line{ pos, std::move(line) });
-        pos += m_lines.back().length();
+        m_lines.emplace_back(std::move(line));
     }
     m_fs_timestamp = fs_timestamp;
 
@@ -135,7 +131,7 @@ ByteCoord Buffer::clamp(ByteCoord coord) const
 
 ByteCoord Buffer::offset_coord(ByteCoord coord, CharCount offset)
 {
-    auto& line = m_lines[coord.line].content;
+    auto& line = m_lines[coord.line];
     auto character = std::max(0_char, std::min(line.char_count_to(coord.column) + offset,
                                                line.char_length() - 1));
     return {coord.line, line.byte_count_to(character)};
@@ -143,9 +139,9 @@ ByteCoord Buffer::offset_coord(ByteCoord coord, CharCount offset)
 
 ByteCoord Buffer::offset_coord(ByteCoord coord, LineCount offset)
 {
-    auto character = m_lines[coord.line].content.char_count_to(coord.column);
+    auto character = m_lines[coord.line].char_count_to(coord.column);
     auto line = Kakoune::clamp(coord.line + offset, 0_line, line_count()-1);
-    auto& content = m_lines[line].content;
+    auto& content = m_lines[line];
 
     character = std::max(0_char, std::min(character, content.char_length() - 2));
     return {line, content.byte_count_to(character)};
@@ -162,7 +158,7 @@ String Buffer::string(ByteCoord begin, ByteCoord end) const
         ByteCount count = -1;
         if (line == end.line)
             count = end.column - start;
-        res += m_lines[line].content.substr(start, count);
+        res += m_lines[line].substr(start, count);
     }
     return res;
 }
@@ -423,14 +419,11 @@ bool Buffer::redo()
 void Buffer::check_invariant() const
 {
 #ifdef KAK_DEBUG
-    ByteCount start = 0;
     kak_assert(not m_lines.empty());
     for (auto& line : m_lines)
     {
-        kak_assert(line.start == start);
         kak_assert(line.length() > 0);
-        kak_assert(line.content.back() == '\n');
-        start += line.length();
+        kak_assert(line.back() == '\n');
     }
 #endif
 }
@@ -442,12 +435,6 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
     if (content.empty())
         return pos;
 
-    ByteCount offset = this->offset(pos);
-
-    // all following lines advanced by length
-    for (LineCount i = pos.line+1; i < line_count(); ++i)
-        m_lines[i].start += content.length();
-
     ByteCoord begin;
     ByteCoord end;
     bool at_end = false;
@@ -460,23 +447,23 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
         {
             if (content[i] == '\n')
             {
-                m_lines.push_back({ offset + start, content.substr(start, i + 1 - start) });
+                m_lines.push_back(content.substr(start, i + 1 - start));
                 start = i + 1;
             }
         }
         if (start != content.length())
-            m_lines.push_back({ offset + start, content.substr(start) });
+            m_lines.push_back(content.substr(start));
 
         begin = pos.column == 0 ? pos : ByteCoord{ pos.line + 1, 0 };
-        end = ByteCoord{ line_count()-1, m_lines.back().length() };
+        end = ByteCoord{ line_count(), 0 };
         at_end = true;
     }
     else
     {
-        String prefix = m_lines[pos.line].content.substr(0, pos.column);
-        String suffix = m_lines[pos.line].content.substr(pos.column);
+        String prefix = m_lines[pos.line].substr(0, pos.column);
+        String suffix = m_lines[pos.line].substr(pos.column);
 
-        std::vector<Line> new_lines;
+        std::vector<String> new_lines;
 
         ByteCount start = 0;
         for (ByteCount i = 0; i < content.length(); ++i)
@@ -487,18 +474,17 @@ ByteCoord Buffer::do_insert(ByteCoord pos, const String& content)
                 if (start == 0)
                 {
                     line_content = prefix + line_content;
-                    new_lines.push_back({ offset + start - prefix.length(),
-                                          std::move(line_content) });
+                    new_lines.push_back(std::move(line_content));
                 }
                 else
-                    new_lines.push_back({ offset + start, std::move(line_content) });
+                    new_lines.push_back(std::move(line_content));
                 start = i + 1;
             }
         }
         if (start == 0)
-            new_lines.push_back({ offset + start - prefix.length(), prefix + content + suffix });
+            new_lines.push_back(prefix + content + suffix);
         else if (start != content.length() or not suffix.empty())
-            new_lines.push_back({ offset + start, content.substr(start) + suffix });
+            new_lines.push_back(content.substr(start) + suffix);
 
         LineCount last_line = pos.line + new_lines.size() - 1;
 
@@ -520,10 +506,9 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
 {
     kak_assert(is_valid(begin));
     kak_assert(is_valid(end));
-    const ByteCount length = distance(begin, end);
-    String prefix = m_lines[begin.line].content.substr(0, begin.column);
-    String suffix = m_lines[end.line].content.substr(end.column);
-    Line new_line = { m_lines[begin.line].start, prefix + suffix };
+    String prefix = m_lines[begin.line].substr(0, begin.column);
+    String suffix = m_lines[end.line].substr(end.column);
+    String new_line = prefix + suffix;
 
     ByteCoord next;
     if (new_line.length() != 0)
@@ -538,9 +523,6 @@ ByteCoord Buffer::do_erase(ByteCoord begin, ByteCoord end)
         next = is_end(begin) ? end_coord() : ByteCoord{begin.line, 0};
     }
 
-    for (LineCount i = begin.line+1; i < line_count(); ++i)
-        m_lines[i].start -= length;
-
     m_changes.push_back({ Change::Erase, begin, end, is_end(begin) });
     return next;
 }
@@ -626,17 +608,38 @@ void Buffer::notify_saved()
 
 ByteCoord Buffer::advance(ByteCoord coord, ByteCount count) const
 {
-    ByteCount off = Kakoune::clamp(offset(coord) + count, 0_byte, byte_count());
-    auto it = std::upper_bound(m_lines.begin(), m_lines.end(), off,
-                               [](ByteCount s, const Line& l) { return s < l.start; }) - 1;
-    return { LineCount{ (int)(it - m_lines.begin()) }, off - it->start };
+    if (count > 0)
+    {
+        auto line = coord.line;
+        count += coord.column;
+        while (count >= m_lines[line].length())
+        {
+            count -= m_lines[line++].length();
+            if (line == line_count())
+                return end_coord();
+        }
+        return { line, count };
+    }
+    else if (count < 0)
+    {
+        auto line = coord.line;
+        count += coord.column;
+        while (count < 0)
+        {
+            count += m_lines[--line].length();
+            if (line < 0)
+                return {0, 0};
+        }
+        return { line, count };
+    }
+    return coord;
 }
 
 ByteCoord Buffer::char_next(ByteCoord coord) const
 {
     if (coord.column < m_lines[coord.line].length() - 1)
     {
-        auto& line = m_lines[coord.line].content;
+        auto& line = m_lines[coord.line];
         coord.column += utf8::codepoint_size(line.begin() + (int)coord.column);
         // Handle invalid utf-8
         if (coord.column >= line.length())
@@ -667,7 +670,7 @@ ByteCoord Buffer::char_prev(ByteCoord coord) const
     }
     else
     {
-        auto& line = m_lines[coord.line].content;
+        auto& line = m_lines[coord.line];
         coord.column = (int)(utf8::character_start(line.begin() + (int)coord.column - 1) - line.begin());
     }
     return coord;
diff --git a/src/buffer.hh b/src/buffer.hh
index 8be177e3..2aa38ad3 100644
--- a/src/buffer.hh
+++ b/src/buffer.hh
@@ -105,7 +105,6 @@ public:
     String         string(ByteCoord begin, ByteCoord end) const;
 
     char           byte_at(ByteCoord c) const;
-    ByteCount      offset(ByteCoord c) const;
     ByteCount      distance(ByteCoord begin, ByteCoord end) const;
     ByteCoord      advance(ByteCoord coord, ByteCount count) const;
     ByteCoord      next(ByteCoord coord) const;
@@ -124,11 +123,10 @@ public:
 
     BufferIterator begin() const;
     BufferIterator end() const;
-    ByteCount      byte_count() const;
     LineCount      line_count() const;
 
     const String&  operator[](LineCount line) const
-    { return m_lines[line].content; }
+    { return m_lines[line]; }
 
     // returns an iterator at given coordinates. clamp line_and_column
     BufferIterator iterator_at(ByteCoord coord) const;
@@ -177,20 +175,13 @@ private:
 
     void on_option_changed(const Option& option) override;
 
-    struct Line
+    struct LineList : std::vector<String>
     {
-        ByteCount start;
-        String    content;
+        String& operator[](LineCount line)
+        { return std::vector<String>::operator[]((int)line); }
 
-        ByteCount length() const { return content.length(); }
-    };
-    struct LineList : std::vector<Line>
-    {
-        Line& operator[](LineCount line)
-        { return std::vector<Line>::operator[]((int)line); }
-
-        const Line& operator[](LineCount line) const
-        { return std::vector<Line>::operator[]((int)line); }
+        const String& operator[](LineCount line) const
+        { return std::vector<String>::operator[]((int)line); }
     };
     LineList m_lines;
 
diff --git a/src/buffer.inl.hh b/src/buffer.inl.hh
index 66e82c92..f457eb0f 100644
--- a/src/buffer.inl.hh
+++ b/src/buffer.inl.hh
@@ -9,7 +9,7 @@ namespace Kakoune
 inline char Buffer::byte_at(ByteCoord c) const
 {
     kak_assert(c.line < line_count() and c.column < m_lines[c.line].length());
-    return m_lines[c.line].content[c.column];
+    return m_lines[c.line][c.column];
 }
 
 inline ByteCoord Buffer::next(ByteCoord coord) const
@@ -40,14 +40,19 @@ inline ByteCoord Buffer::prev(ByteCoord coord) const
 
 inline ByteCount Buffer::distance(ByteCoord begin, ByteCoord end) const
 {
-    return offset(end) - offset(begin);
-}
-
-inline ByteCount Buffer::offset(ByteCoord c) const
-{
-    if (c.line == line_count())
-        return m_lines.back().start + m_lines.back().length();
-    return m_lines[c.line].start + c.column;
+    if (begin > end)
+        return -distance(end, begin);
+    ByteCount res = 0;
+    for (LineCount l = begin.line; l <= end.line; ++l)
+    {
+        ByteCount len = m_lines[l].length();
+        res += len;
+        if (l == begin.line)
+            res -= begin.column;
+        if (l == end.line)
+            res -= len - end.column;
+    }
+    return res;
 }
 
 inline bool Buffer::is_valid(ByteCoord c) const
@@ -77,13 +82,6 @@ inline BufferIterator Buffer::end() const
     return BufferIterator(*this, { line_count() - 1, m_lines.back().length() });
 }
 
-inline ByteCount Buffer::byte_count() const
-{
-    if (m_lines.empty())
-        return 0;
-    return m_lines.back().start + m_lines.back().length();
-}
-
 inline LineCount Buffer::line_count() const
 {
     return LineCount(m_lines.size());
diff --git a/src/insert_completer.cc b/src/insert_completer.cc
index def3b951..2feddbb6 100644
--- a/src/insert_completer.cc
+++ b/src/insert_completer.cc
@@ -189,14 +189,13 @@ void InsertCompleter::select(int offset)
     const auto& cursor_pos = selections.main().cursor();
     const auto prefix_len = buffer.distance(m_completions.begin, cursor_pos);
     const auto suffix_len = std::max(0_byte, buffer.distance(cursor_pos, m_completions.end));
-    const auto buffer_len = buffer.byte_count();
 
     auto ref = buffer.string(m_completions.begin, m_completions.end);
     for (auto& sel : selections)
     {
-        auto offset = buffer.offset(sel.cursor());
-        auto pos = buffer.iterator_at(sel.cursor());
-        if (offset >= prefix_len and offset + suffix_len < buffer_len and
+        const auto& cursor = sel.cursor();
+        auto pos = buffer.iterator_at(cursor);
+        if (cursor.column >= prefix_len and (pos + suffix_len) != buffer.end() and
             std::equal(ref.begin(), ref.end(), pos - prefix_len))
         {
             pos = buffer.erase(pos - prefix_len, pos + suffix_len);
diff --git a/src/selectors.cc b/src/selectors.cc
index 2e823d9d..bcae7a06 100644
--- a/src/selectors.cc
+++ b/src/selectors.cc
@@ -288,7 +288,7 @@ Selection select_whole_paragraph(const Buffer& buffer, const Selection& selectio
 {
     BufferIterator first = buffer.iterator_at(selection.cursor());
 
-    if (not (flags & ObjectFlags::ToEnd) and buffer.offset(first.coord()) > 1 and
+    if (not (flags & ObjectFlags::ToEnd) and first.coord() > ByteCoord{0,1} and
         *(first-1) == '\n' and *(first-2) == '\n')
         --first;
     else if ((flags & ObjectFlags::ToEnd) and
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index 16b6b122..c7569804 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -27,6 +27,9 @@ void test_buffer()
     kak_assert(pos.coord() == ByteCoord{1 COMMA 0});
     buffer.insert(pos, "tchou kanaky\n");
     kak_assert(buffer.line_count() == 5);
+    BufferIterator pos2 = buffer.end();
+    pos2 -= 9;
+    kak_assert(*pos2 == '?');
 
     String str = buffer.string({ 4, 1 }, buffer.next({ 4, 5 }));
     kak_assert(str == "youpi");

From fc0700d1fde9281a459feb6ab0cb0c7873ccdb9a Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 24 May 2014 17:17:14 +0100
Subject: [PATCH 31/53] Fix segfault in region highlighter

---
 src/highlighters.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/highlighters.cc b/src/highlighters.cc
index 19d7ac3f..28c208f3 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -805,10 +805,10 @@ private:
         for (auto& modif : modifs)
         {
             for (auto line = std::max(last_line + 1, modif.new_coord.line);
-                 line <= modif.new_coord.line + modif.num_added.line;
+                 line <= modif.new_coord.line + modif.num_added.line and
+                 line < buffer.line_count();
                  ++line)
             {
-                kak_assert(line < buffer.line_count());
                 auto& l = buffer[line];
                 using RegexIt = boost::regex_iterator<String::const_iterator>;
                 for (RegexIt it{l.begin(), l.end(), regex}, end; it != end; ++it)

From b2621ca140701269056c75983a8c1220b8382684 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 25 May 2014 20:28:32 +0100
Subject: [PATCH 32/53] Move insert/erase methods from normal.cc to member
 functions in SelectionList

It does look like the Editor class is attempting a sneaky comeback...
---
 src/normal.cc    | 116 +++++++----------------------------------------
 src/normal.hh    |  12 -----
 src/selection.cc |  88 +++++++++++++++++++++++++++++++++--
 src/selection.hh |  41 +++++++++--------
 src/selectors.cc |  11 +++--
 src/selectors.hh |  12 ++---
 6 files changed, 136 insertions(+), 144 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index cc611d9f..c8ff9c78 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -22,86 +22,6 @@
 namespace Kakoune
 {
 
-void erase(Buffer& buffer, SelectionList& selections)
-{
-    for (auto& sel : reversed(selections))
-    {
-        erase(buffer, sel);
-    }
-    selections.update();
-    selections.avoid_eol();
-    buffer.check_invariant();
-}
-
-template<InsertMode mode>
-BufferIterator prepare_insert(Buffer& buffer, const Selection& sel)
-{
-    switch (mode)
-    {
-    case InsertMode::Insert:
-        return buffer.iterator_at(sel.min());
-    case InsertMode::Replace:
-        return Kakoune::erase(buffer, sel);
-    case InsertMode::Append:
-    {
-        // special case for end of lines, append to current line instead
-        auto pos = buffer.iterator_at(sel.max());
-        return *pos == '\n' ? pos : utf8::next(pos);
-    }
-    case InsertMode::InsertAtLineBegin:
-        return buffer.iterator_at(sel.min().line);
-    case InsertMode::AppendAtLineEnd:
-        return buffer.iterator_at({sel.max().line, buffer[sel.max().line].length() - 1});
-    case InsertMode::InsertAtNextLineBegin:
-        return buffer.iterator_at(sel.max().line+1);
-    case InsertMode::OpenLineBelow:
-        return buffer.insert(buffer.iterator_at(sel.max().line + 1), "\n");
-    case InsertMode::OpenLineAbove:
-        return buffer.insert(buffer.iterator_at(sel.min().line), "\n");
-    }
-    kak_assert(false);
-    return {};
-}
-
-template<InsertMode mode>
-void insert(Buffer& buffer, SelectionList& selections, memoryview<String> strings)
-{
-    if (strings.empty())
-        return;
-
-    selections.update();
-    for (size_t i = 0; i < selections.size(); ++i)
-    {
-        size_t index = selections.size() - 1 - i;
-        auto& sel = selections[index];
-        auto pos = prepare_insert<mode>(buffer, sel);
-        const String& str = strings[std::min(index, strings.size()-1)];
-        pos = buffer.insert(pos, str);
-        if (mode == InsertMode::Replace)
-        {
-             if (pos == buffer.end())
-                 --pos;
-            sel.anchor() = pos.coord();
-            sel.cursor() = (str.empty() ?
-                pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
-
-           // update following selections
-           auto changes = compute_modifications(buffer, selections.timestamp());
-           for (size_t j = index+1; j < selections.size(); ++j)
-           {
-               auto& sel = selections[j];
-               sel.anchor() = update_pos(changes, sel.anchor());
-               sel.cursor() = update_pos(changes, sel.cursor());
-           }
-           selections.update_timestamp();
-        }
-    }
-    selections.update();
-    selections.avoid_eol();
-    selections.check_invariant();
-    buffer.check_invariant();
-}
-
 using namespace std::placeholders;
 
 enum class SelectMode
@@ -172,7 +92,7 @@ constexpr Select<mode, T> make_select(T func)
 }
 
 template<SelectMode mode = SelectMode::Replace>
-void select_coord(const Buffer& buffer, ByteCoord coord, SelectionList& selections)
+void select_coord(Buffer& buffer, ByteCoord coord, SelectionList& selections)
 {
     coord = buffer.clamp(coord);
     if (mode == SelectMode::Replace)
@@ -405,7 +325,7 @@ void replace_with_char(Context& context, int)
             CharCount count = char_length(buffer, sel);
             strings.emplace_back(key.key, count);
         }
-        insert<InsertMode::Replace>(buffer, selections, strings);
+        selections.insert(strings, InsertMode::Replace);
     }, "replace with char", "enter char to replace with\n");
 }
 
@@ -428,7 +348,7 @@ void for_each_char(Context& context, int)
         for (auto& c : sel)
             c = func(c);
     }
-    insert<InsertMode::Replace>(context.buffer(), context.selections(), sels);
+    context.selections().insert(sels, InsertMode::Replace);
 }
 
 void command(Context& context, int)
@@ -493,7 +413,7 @@ void pipe(Context& context, int)
                 strings.push_back(str);
             }
             ScopedEdition edition(context);
-            insert<mode>(buffer, selections, strings);
+            selections.insert(strings, mode);
         });
 }
 
@@ -543,7 +463,7 @@ void erase_selections(Context& context, int)
 {
     RegisterManager::instance()['"'] = context.selections_content();
     ScopedEdition edition(context);
-    erase(context.buffer(), context.selections());
+    context.selections().erase();
 }
 
 void cat_erase_selections(Context& context, int)
@@ -553,7 +473,7 @@ void cat_erase_selections(Context& context, int)
     for (auto& sel : sels)
         str += sel;
     RegisterManager::instance()['"'] = memoryview<String>(str);
-    erase(context.buffer(), context.selections());
+    context.selections().erase();
 }
 
 
@@ -587,10 +507,8 @@ void paste(Context& context, int)
         }
     }
     ScopedEdition edition(context);
-    if (linewise)
-        insert<adapt_for_linewise(mode)>(context.buffer(), context.selections(), strings);
-    else
-        insert<mode>(context.buffer(), context.selections(), strings);
+    context.selections().insert(strings,
+                                linewise ? adapt_for_linewise(mode) : mode);
 }
 
 template<typename T>
@@ -717,7 +635,7 @@ void select_regex(Context& context, int)
         else
             RegisterManager::instance()['/'] = String{ex.str()};
         if (not ex.empty() and not ex.str().empty())
-            select_all_matches(context.buffer(), context.selections(), ex);
+            select_all_matches(context.selections(), ex);
     });
 }
 
@@ -729,7 +647,7 @@ void split_regex(Context& context, int)
         else
             RegisterManager::instance()['/'] = String{ex.str()};
         if (not ex.empty() and not ex.str().empty())
-            split_selections(context.buffer(), context.selections(), ex);
+            split_selections(context.selections(), ex);
     });
 }
 
@@ -775,7 +693,7 @@ void join_select_spaces(Context& context, int)
         return;
     context.selections() = selections;
     ScopedEdition edition(context);
-    insert<InsertMode::Replace>(buffer, context.selections(), " "_str);
+    context.selections().insert(" "_str, InsertMode::Replace);
 }
 
 void join(Context& context, int param)
@@ -853,7 +771,7 @@ void indent(Context& context, int)
     {
         ScopedEdition edition(context);
         SelectionList selections{buffer, std::move(sels)};
-        insert<InsertMode::Insert>(buffer, selections, indent);
+        selections.insert(indent, InsertMode::Insert);
     }
 }
 
@@ -898,7 +816,7 @@ void deindent(Context& context, int)
     {
         ScopedEdition edition(context);
         SelectionList selections{context.buffer(), std::move(sels)};
-        erase(context.buffer(), selections);
+        selections.erase();
     }
 }
 
@@ -1008,7 +926,7 @@ void rotate_selections_content(Context& context, int group)
         std::rotate(it, end-count, end);
         it = end;
     }
-    insert<InsertMode::Replace>(context.buffer(), context.selections(), strings);
+    context.selections().insert(strings, InsertMode::Replace);
     context.selections().rotate_main(count);
 }
 
@@ -1236,7 +1154,7 @@ void spaces_to_tabs(Context& context, int ts)
     }
 }
 
-static boost::optional<SelectionList> compute_modified_ranges(const Buffer& buffer, size_t timestamp)
+static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, size_t timestamp)
 {
     std::vector<Selection> ranges;
     for (auto& change : buffer.changes_since(timestamp))
@@ -1402,12 +1320,12 @@ KeyMap keymap =
 
     { '.', repeat_last_insert },
 
-    { '%', [](Context& context, int) { select_whole_buffer(context.buffer(), context.selections()); } },
+    { '%', [](Context& context, int) { select_whole_buffer(context.selections()); } },
 
     { ':', command },
     { '|', pipe<InsertMode::Replace> },
     { alt('|'), pipe<InsertMode::Append> },
-    { ' ', [](Context& context, int count) { if (count == 0) clear_selections(context.buffer(), context.selections());
+    { ' ', [](Context& context, int count) { if (count == 0) clear_selections(context.selections());
                                              else keep_selection(context.selections(), count-1); } },
     { alt(' '), [](Context& context, int count) { if (count == 0) flip_selections(context.selections());
                                                   else remove_selection(context.selections(), count-1); } },
diff --git a/src/normal.hh b/src/normal.hh
index e72d0d20..c35027ce 100644
--- a/src/normal.hh
+++ b/src/normal.hh
@@ -11,18 +11,6 @@ namespace Kakoune
 
 class Context;
 
-enum class InsertMode : unsigned
-{
-    Insert,
-    Append,
-    Replace,
-    InsertAtLineBegin,
-    InsertAtNextLineBegin,
-    AppendAtLineEnd,
-    OpenLineBelow,
-    OpenLineAbove
-};
-
 using KeyMap = std::unordered_map<Key, std::function<void (Context& context, int param)>>;
 extern KeyMap keymap;
 
diff --git a/src/selection.cc b/src/selection.cc
index 176bc076..7b99cc6d 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -2,6 +2,7 @@
 
 #include "utf8.hh"
 #include "modification.hh"
+#include "buffer_utils.hh"
 
 namespace Kakoune
 {
@@ -102,24 +103,24 @@ struct UpdateErase
 
 }
 
-SelectionList::SelectionList(const Buffer& buffer, Selection s, size_t timestamp)
+SelectionList::SelectionList(Buffer& buffer, Selection s, size_t timestamp)
     : m_buffer(&buffer), m_selections({ s }), m_timestamp(timestamp)
 {
     check_invariant();
 }
 
-SelectionList::SelectionList(const Buffer& buffer, Selection s)
+SelectionList::SelectionList(Buffer& buffer, Selection s)
     : SelectionList(buffer, s, buffer.timestamp())
 {}
 
-SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp)
+SelectionList::SelectionList(Buffer& buffer, std::vector<Selection> s, size_t timestamp)
     : m_buffer(&buffer), m_selections(std::move(s)), m_timestamp(timestamp)
 {
     kak_assert(size() > 0);
     check_invariant();
 }
 
-SelectionList::SelectionList(const Buffer& buffer, std::vector<Selection> s)
+SelectionList::SelectionList(Buffer& buffer, std::vector<Selection> s)
     : SelectionList(buffer, std::move(s), buffer.timestamp())
 {}
 
@@ -221,4 +222,83 @@ void SelectionList::avoid_eol()
         _avoid_eol(buffer(), sel);
 }
 
+void SelectionList::erase()
+{
+    for (auto& sel : reversed(m_selections))
+    {
+        Kakoune::erase(*m_buffer, sel);
+    }
+    update();
+    avoid_eol();
+    m_buffer->check_invariant();
+}
+
+BufferIterator prepare_insert(Buffer& buffer, const Selection& sel, InsertMode mode)
+{
+    switch (mode)
+    {
+    case InsertMode::Insert:
+        return buffer.iterator_at(sel.min());
+    case InsertMode::Replace:
+        return erase(buffer, sel);
+    case InsertMode::Append:
+    {
+        // special case for end of lines, append to current line instead
+        auto pos = buffer.iterator_at(sel.max());
+        return *pos == '\n' ? pos : utf8::next(pos);
+    }
+    case InsertMode::InsertAtLineBegin:
+        return buffer.iterator_at(sel.min().line);
+    case InsertMode::AppendAtLineEnd:
+        return buffer.iterator_at({sel.max().line, buffer[sel.max().line].length() - 1});
+    case InsertMode::InsertAtNextLineBegin:
+        return buffer.iterator_at(sel.max().line+1);
+    case InsertMode::OpenLineBelow:
+        return buffer.insert(buffer.iterator_at(sel.max().line + 1), "\n");
+    case InsertMode::OpenLineAbove:
+        return buffer.insert(buffer.iterator_at(sel.min().line), "\n");
+    }
+    kak_assert(false);
+    return {};
+}
+
+void SelectionList::insert(memoryview<String> strings, InsertMode mode)
+{
+    if (strings.empty())
+        return;
+
+    update();
+    for (size_t i = 0; i < m_selections.size(); ++i)
+    {
+        size_t index = m_selections.size() - 1 - i;
+        auto& sel = m_selections[index];
+        auto pos = prepare_insert(*m_buffer, sel, mode);
+        const String& str = strings[std::min(index, strings.size()-1)];
+        pos = m_buffer->insert(pos, str);
+        if (mode == InsertMode::Replace)
+        {
+             if (pos == m_buffer->end())
+                 --pos;
+            sel.anchor() = pos.coord();
+            sel.cursor() = (str.empty() ?
+                pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
+
+           // update following selections
+           auto changes = compute_modifications(*m_buffer, timestamp());
+           for (size_t j = index+1; j < m_selections.size(); ++j)
+           {
+               auto& sel = m_selections[j];
+               sel.anchor() = update_pos(changes, sel.anchor());
+               sel.cursor() = update_pos(changes, sel.cursor());
+           }
+           update_timestamp();
+        }
+    }
+    update();
+    avoid_eol();
+    check_invariant();
+    m_buffer->check_invariant();
+}
+
+
 }
diff --git a/src/selection.hh b/src/selection.hh
index cd60f817..a1bf8e5c 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -55,12 +55,24 @@ static bool compare_selections(const Selection& lhs, const Selection& rhs)
     return lhs.min() < rhs.min();
 }
 
+enum class InsertMode : unsigned
+{
+    Insert,
+    Append,
+    Replace,
+    InsertAtLineBegin,
+    InsertAtNextLineBegin,
+    AppendAtLineEnd,
+    OpenLineBelow,
+    OpenLineAbove
+};
+
 struct SelectionList
 {
-    SelectionList(const Buffer& buffer, Selection s);
-    SelectionList(const Buffer& buffer, Selection s, size_t timestamp);
-    SelectionList(const Buffer& buffer, std::vector<Selection> s);
-    SelectionList(const Buffer& buffer, std::vector<Selection> s, size_t timestamp);
+    SelectionList(Buffer& buffer, Selection s);
+    SelectionList(Buffer& buffer, Selection s, size_t timestamp);
+    SelectionList(Buffer& buffer, std::vector<Selection> s);
+    SelectionList(Buffer& buffer, std::vector<Selection> s, size_t timestamp);
 
     void update();
 
@@ -103,17 +115,7 @@ struct SelectionList
     const_iterator begin() const { return m_selections.begin(); }
     const_iterator end() const { return m_selections.end(); }
 
-    template<typename... Args>
-    iterator insert(Args... args)
-    {
-        return m_selections.insert(std::forward<Args>(args)...);
-    }
-
-    template<typename... Args>
-    iterator erase(Args... args)
-    {
-        return m_selections.erase(std::forward<Args>(args)...);
-    }
+    void remove(size_t index) { m_selections.erase(begin() + index); }
 
     size_t size() const { return m_selections.size(); }
 
@@ -140,22 +142,25 @@ struct SelectionList
                     (*this)[i] = std::move((*this)[j]);
             }
         }
-        erase(begin() + i + 1, end());
+        m_selections.erase(begin() + i + 1, end());
         kak_assert(std::is_sorted(begin(), end(), compare_selections));
     }
 
     void sort_and_merge_overlapping();
 
-    const Buffer& buffer() const { return *m_buffer; }
+    Buffer& buffer() const { return *m_buffer; }
 
     size_t timestamp() const { return m_timestamp; }
     void update_timestamp() { m_timestamp = m_buffer->timestamp(); }
 
+    void insert(memoryview<String> strings, InsertMode mode);
+    void erase();
+
 private:
     size_t m_main = 0;
     std::vector<Selection> m_selections;
 
-    safe_ptr<const Buffer> m_buffer;
+    safe_ptr<Buffer> m_buffer;
     size_t m_timestamp;
 };
 
diff --git a/src/selectors.cc b/src/selectors.cc
index bcae7a06..fb416aff 100644
--- a/src/selectors.cc
+++ b/src/selectors.cc
@@ -429,15 +429,16 @@ Selection trim_partial_lines(const Buffer& buffer, const Selection& selection)
     return Selection(first.coord(), last.coord());
 }
 
-void select_whole_buffer(const Buffer& buffer, SelectionList& selections)
+void select_whole_buffer(SelectionList& selections)
 {
+    auto& buffer = selections.buffer();
     selections = SelectionList{ buffer, Selection({0,0}, buffer.back_coord()) };
 }
 
-void select_all_matches(const Buffer& buffer, SelectionList& selections,
-                        const Regex& regex)
+void select_all_matches(SelectionList& selections, const Regex& regex)
 {
     std::vector<Selection> result;
+    auto& buffer = selections.buffer();
     for (auto& sel : selections)
     {
         auto sel_end = utf8::next(buffer.iterator_at(sel.max()));
@@ -466,10 +467,10 @@ void select_all_matches(const Buffer& buffer, SelectionList& selections,
     selections = std::move(result);
 }
 
-void split_selections(const Buffer& buffer, SelectionList& selections,
-                      const Regex& regex)
+void split_selections(SelectionList& selections, const Regex& regex)
 {
     std::vector<Selection> result;
+    auto& buffer = selections.buffer();
     for (auto& sel : selections)
     {
         auto begin = buffer.iterator_at(sel.min());
diff --git a/src/selectors.hh b/src/selectors.hh
index d5b0523d..717dff93 100644
--- a/src/selectors.hh
+++ b/src/selectors.hh
@@ -9,14 +9,14 @@
 namespace Kakoune
 {
 
-inline void clear_selections(const Buffer& buffer, SelectionList& selections)
+inline void clear_selections(SelectionList& selections)
 {
     auto& sel = selections.main();
     auto& pos = sel.cursor();
     sel.anchor() = pos;
     selections.avoid_eol();
 
-    selections = SelectionList{ buffer, std::move(sel) };
+    selections = SelectionList{ selections.buffer(), std::move(sel) };
 }
 
 inline void flip_selections(SelectionList& selections)
@@ -41,7 +41,7 @@ inline void remove_selection(SelectionList& selections, int index)
     if (selections.size() > 1 and index < selections.size())
     {
         size_t real_index = (index + selections.main_index() + 1) % selections.size();
-        selections.erase(selections.begin() + real_index);
+        selections.remove(real_index);
         size_t main_index = selections.main_index();
         if (real_index <= main_index)
             selections.set_main_index((main_index > 0 ? main_index
@@ -207,7 +207,7 @@ Selection select_whole_paragraph(const Buffer& buffer, const Selection& selectio
 Selection select_whole_indent(const Buffer& buffer, const Selection& selection,
                               ObjectFlags flags);
 Selection select_whole_lines(const Buffer& buffer, const Selection& selection);
-void select_whole_buffer(const Buffer& buffer, SelectionList& selections);
+void select_whole_buffer(SelectionList& selections);
 Selection trim_partial_lines(const Buffer& buffer, const Selection& selection);
 
 enum Direction { Forward, Backward };
@@ -266,10 +266,10 @@ Selection find_next_match(const Buffer& buffer, const Selection& sel, const Rege
     return {begin.coord(), end.coord(), std::move(captures)};
 }
 
-void select_all_matches(const Buffer& buffer, SelectionList& selections,
+void select_all_matches(SelectionList& selections,
                         const Regex& regex);
 
-void split_selections(const Buffer& buffer, SelectionList& selections,
+void split_selections(SelectionList& selections,
                       const Regex& separator_regex);
 
 using CodepointPair = std::pair<Codepoint, Codepoint>;

From 51eae8026b5e7a596ad3ec787ade96e8e78d7c33 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 25 May 2014 22:59:29 +0100
Subject: [PATCH 33/53] Use SelectionList::insert in InputModes::Insert

---
 src/input_handler.cc | 18 +++---------------
 src/selection.cc     |  3 ++-
 src/selection.hh     |  1 +
 3 files changed, 6 insertions(+), 16 deletions(-)

diff --git a/src/input_handler.cc b/src/input_handler.cc
index 4c718c21..60cfb618 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -759,26 +759,13 @@ private:
 
     void insert(memoryview<String> strings)
     {
-        auto& buffer = context().buffer();
-        auto& selections = context().selections();
-        for (size_t i = 0; i < selections.size(); ++i)
-        {
-            size_t index = selections.size() - 1 - i;
-            const String& str = strings[std::min(index, strings.size()-1)];
-            buffer.insert(buffer.iterator_at(selections[index].cursor()),
-                          str);
-        }
-        selections.update();
+        context().selections().insert(strings, InsertMode::InsertCursor);
     }
 
     void insert(Codepoint key)
     {
         auto str = codepoint_to_str(key);
-        auto& buffer = context().buffer();
-        auto& selections = context().selections();
-        for (auto& sel : reversed(selections))
-            buffer.insert(buffer.iterator_at(sel.cursor()), str);
-        selections.update();
+        context().selections().insert(str, InsertMode::InsertCursor);
         context().hooks().run_hook("InsertChar", str, context());
     }
 
@@ -828,6 +815,7 @@ private:
                 cursor = anchor;
                 break;
             case InsertMode::InsertAtNextLineBegin:
+            case InsertMode::InsertCursor:
                  kak_assert(false); // not implemented
                  break;
             }
diff --git a/src/selection.cc b/src/selection.cc
index 7b99cc6d..c37829c2 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -239,6 +239,8 @@ BufferIterator prepare_insert(Buffer& buffer, const Selection& sel, InsertMode m
     {
     case InsertMode::Insert:
         return buffer.iterator_at(sel.min());
+    case InsertMode::InsertCursor:
+        return buffer.iterator_at(sel.cursor());
     case InsertMode::Replace:
         return erase(buffer, sel);
     case InsertMode::Append:
@@ -295,7 +297,6 @@ void SelectionList::insert(memoryview<String> strings, InsertMode mode)
         }
     }
     update();
-    avoid_eol();
     check_invariant();
     m_buffer->check_invariant();
 }
diff --git a/src/selection.hh b/src/selection.hh
index a1bf8e5c..75d26728 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -58,6 +58,7 @@ static bool compare_selections(const Selection& lhs, const Selection& rhs)
 enum class InsertMode : unsigned
 {
     Insert,
+    InsertCursor,
     Append,
     Replace,
     InsertAtLineBegin,

From f49bec802157fc592bc6e35755807c6c3a531e78 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 26 May 2014 20:57:10 +0100
Subject: [PATCH 34/53] Go back to Buffer::Change based implementation for
 SelectionList::update

However take into account the ordering of selections in insert and erase
methods, so that we update selection position cheaply.
---
 src/normal.cc    |  10 +-
 src/selection.cc | 274 +++++++++++++++++++++++++----------------------
 src/selection.hh |   4 +-
 3 files changed, 154 insertions(+), 134 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index c8ff9c78..62cfb864 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1163,7 +1163,7 @@ static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, si
         const ByteCoord& end = change.end;
         if (change.type == Buffer::Change::Insert)
         {
-            update_insert(ranges, begin, end, change.at_end);
+            update_insert(ranges, begin, end);
             auto it = std::upper_bound(ranges.begin(), ranges.end(), begin,
                                        [](ByteCoord c, const Selection& sel)
                                        { return c < sel.min(); });
@@ -1171,7 +1171,7 @@ static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, si
         }
         else
         {
-            update_erase(ranges, begin, end, change.at_end);
+            update_erase(ranges, begin, end);
             auto pos = begin;
             if (change.at_end)
                 pos = begin.column ? ByteCoord{begin.line, begin.column - 1}
@@ -1185,6 +1185,12 @@ static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, si
     if (ranges.empty())
         return {};
 
+    for (auto& sel : ranges)
+    {
+        sel.anchor() = buffer.clamp(sel.anchor());
+        sel.cursor() = buffer.clamp(sel.cursor());
+    }
+
     SelectionList result{buffer, std::move(ranges)};
 
     auto touches = [&](const Selection& lhs, const Selection& rhs) {
diff --git a/src/selection.cc b/src/selection.cc
index c37829c2..d3c798b0 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -1,7 +1,6 @@
 #include "selection.hh"
 
 #include "utf8.hh"
-#include "modification.hh"
 #include "buffer_utils.hh"
 
 namespace Kakoune
@@ -16,93 +15,6 @@ void Selection::merge_with(const Selection& range)
         m_anchor = std::max(m_anchor, range.m_anchor);
 }
 
-namespace
-{
-
-template<template <bool, bool> class UpdateFunc>
-void on_buffer_change(std::vector<Selection>& sels,
-                      ByteCoord begin, ByteCoord end, bool at_end, LineCount end_line)
-{
-    auto update_beg = std::lower_bound(sels.begin(), sels.end(), begin,
-                                       [](const Selection& s, ByteCoord c)
-                                       { return s.max() < c; });
-    auto update_only_line_beg = std::upper_bound(sels.begin(), sels.end(), end_line,
-                                                 [](LineCount l, const Selection& s)
-                                                 { return l < s.min().line; });
-
-    if (update_beg != update_only_line_beg)
-    {
-        // for the first one, we are not sure if min < begin
-        UpdateFunc<false, false>{}(update_beg->anchor(), begin, end, at_end);
-        UpdateFunc<false, false>{}(update_beg->cursor(), begin, end, at_end);
-    }
-    for (auto it = update_beg+1; it < update_only_line_beg; ++it)
-    {
-        UpdateFunc<false, true>{}(it->anchor(), begin, end, at_end);
-        UpdateFunc<false, true>{}(it->cursor(), begin, end, at_end);
-    }
-    if (end.line > begin.line)
-    {
-        for (auto it = update_only_line_beg; it != sels.end(); ++it)
-        {
-            UpdateFunc<true, true>{}(it->anchor(), begin, end, at_end);
-            UpdateFunc<true, true>{}(it->cursor(), begin, end, at_end);
-        }
-    }
-}
-
-template<bool assume_different_line, bool assume_greater_than_begin>
-struct UpdateInsert
-{
-    void operator()(ByteCoord& coord, ByteCoord begin, ByteCoord end,
-                    bool at_end) const
-    {
-        if (assume_different_line)
-            kak_assert(begin.line < coord.line);
-        if (not assume_greater_than_begin and coord < begin)
-            return;
-        if (not assume_different_line and begin.line == coord.line)
-            coord.column = end.column + coord.column - begin.column;
-
-        coord.line += end.line - begin.line;
-        kak_assert(coord.line >= 0 and coord.column >= 0);
-    }
-};
-
-template<bool assume_different_line, bool assume_greater_than_begin>
-struct UpdateErase
-{
-    void operator()(ByteCoord& coord, ByteCoord begin, ByteCoord end,
-                    bool at_end) const
-    {
-        if (not assume_greater_than_begin and coord < begin)
-            return;
-        if (assume_different_line)
-            kak_assert(end.line < coord.line);
-        if (not assume_different_line and coord <= end)
-        {
-            if (not at_end or begin == ByteCoord{0,0})
-                coord = begin;
-            else
-                coord = begin.column ? ByteCoord{begin.line, begin.column-1}
-                                     : ByteCoord{begin.line - 1};
-        }
-        else
-        {
-            if (not assume_different_line and end.line == coord.line)
-            {
-                coord.line = begin.line;
-                coord.column = begin.column + coord.column - end.column;
-            }
-            else
-                coord.line -= end.line - begin.line;
-        }
-        kak_assert(coord.line >= 0 and coord.column >= 0);
-    }
-};
-
-}
-
 SelectionList::SelectionList(Buffer& buffer, Selection s, size_t timestamp)
     : m_buffer(&buffer), m_selections({ s }), m_timestamp(timestamp)
 {
@@ -124,14 +36,41 @@ SelectionList::SelectionList(Buffer& buffer, std::vector<Selection> s)
     : SelectionList(buffer, std::move(s), buffer.timestamp())
 {}
 
-void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end)
+namespace
 {
-    on_buffer_change<UpdateInsert>(sels, begin, end, at_end, begin.line);
+
+ByteCoord update_insert(ByteCoord coord, ByteCoord begin, ByteCoord end)
+{
+    if (coord < begin)
+        return coord;
+    if (begin.line == coord.line)
+        coord.column += end.column - begin.column;
+    coord.line += end.line - begin.line;
+    kak_assert(coord.line >= 0 and coord.column >= 0);
+    return coord;
 }
 
-void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end)
+ByteCoord update_erase(ByteCoord coord, ByteCoord begin, ByteCoord end)
 {
-    on_buffer_change<UpdateErase>(sels, begin, end, at_end, end.line);
+    if (coord < begin)
+        return coord;
+    if (coord <= end)
+        return begin;
+    if (end.line == coord.line)
+        coord.column -= end.column - begin.column;
+    coord.line -= end.line - begin.line;
+    kak_assert(coord.line >= 0 and coord.column >= 0);
+    return coord;
+}
+
+ByteCoord update_pos(ByteCoord coord, const Buffer::Change& change)
+{
+    if (change.type == Buffer::Change::Insert)
+        return update_insert(coord, change.begin, change.end);
+    else  
+        return update_erase(coord, change.begin, change.end);
+}
+
 }
 
 void SelectionList::update()
@@ -139,18 +78,19 @@ void SelectionList::update()
     if (m_timestamp == m_buffer->timestamp())
         return;
 
-    auto modifs = compute_modifications(*m_buffer, m_timestamp);
+    for (auto& change : m_buffer->changes_since(m_timestamp))
+    {
+        for (auto& sel : m_selections)
+        {
+            sel.anchor() = update_pos(sel.anchor(), change);
+            sel.cursor() = update_pos(sel.cursor(), change);
+        }
+    }
     for (auto& sel : m_selections)
     {
-        auto anchor = update_pos(modifs, sel.anchor());
-        kak_assert(m_buffer->is_valid(anchor));
-        sel.anchor() = m_buffer->clamp(anchor);
-
-        auto cursor = update_pos(modifs, sel.cursor());
-        kak_assert(m_buffer->is_valid(cursor));
-        sel.cursor() = m_buffer->clamp(cursor);
+        sel.anchor() = m_buffer->clamp(sel.anchor());
+        sel.cursor() = m_buffer->clamp(sel.cursor());
     }
-
     merge_overlapping(overlaps);
     check_invariant();
 
@@ -222,17 +162,6 @@ void SelectionList::avoid_eol()
         _avoid_eol(buffer(), sel);
 }
 
-void SelectionList::erase()
-{
-    for (auto& sel : reversed(m_selections))
-    {
-        Kakoune::erase(*m_buffer, sel);
-    }
-    update();
-    avoid_eol();
-    m_buffer->check_invariant();
-}
-
 BufferIterator prepare_insert(Buffer& buffer, const Selection& sel, InsertMode mode)
 {
     switch (mode)
@@ -264,42 +193,127 @@ BufferIterator prepare_insert(Buffer& buffer, const Selection& sel, InsertMode m
     return {};
 }
 
+// This tracks position changes for changes that are done
+// in a forward way (each change takes place at a position)
+// *after* the previous one.
+struct PositionChangesTracker 
+{
+    ByteCoord last_pos;
+    ByteCoord pos_change;
+
+    void update(const Buffer::Change& change)
+    {
+        if (change.type == Buffer::Change::Insert)
+        {
+            pos_change.line += change.end.line - change.begin.line;
+            if (change.begin.line != last_pos.line)
+                pos_change.column = 0;
+            pos_change.column += change.end.column - change.begin.column;
+            last_pos = change.end;
+        }
+        else if (change.type == Buffer::Change::Erase)
+        {
+            pos_change.line -= change.end.line - change.begin.line;
+            if (last_pos.line != change.end.line)
+                pos_change.column = 0;
+            pos_change.column -= change.end.column - change.begin.column;
+            last_pos = change.begin;
+        }
+    }
+
+    void update(const Buffer& buffer, size_t& timestamp)
+    {
+        for (auto& change : buffer.changes_since(timestamp))
+            update(change);
+        timestamp = buffer.timestamp();
+    }
+
+    ByteCoord get_new_coord(ByteCoord coord)
+    {
+        if (last_pos.line - pos_change.line == coord.line)
+            coord.column += pos_change.column;
+        coord.line += pos_change.line;
+        return coord;
+    }
+
+    void update_sel(Selection& sel)
+    {
+        sel.anchor() = get_new_coord(sel.anchor());
+        sel.cursor() = get_new_coord(sel.cursor());
+    }
+};
+
 void SelectionList::insert(memoryview<String> strings, InsertMode mode)
 {
     if (strings.empty())
         return;
 
     update();
-    for (size_t i = 0; i < m_selections.size(); ++i)
+    PositionChangesTracker changes_tracker;
+    for (size_t index = 0; index < m_selections.size(); ++index)
     {
-        size_t index = m_selections.size() - 1 - i;
         auto& sel = m_selections[index];
+
+        changes_tracker.update_sel(sel);
+        kak_assert(m_buffer->is_valid(sel.anchor()));
+        kak_assert(m_buffer->is_valid(sel.cursor()));
+
         auto pos = prepare_insert(*m_buffer, sel, mode);
+        changes_tracker.update(*m_buffer, m_timestamp);
+
         const String& str = strings[std::min(index, strings.size()-1)];
         pos = m_buffer->insert(pos, str);
+
+        auto& change = m_buffer->changes_since(m_timestamp).back();
+        changes_tracker.update(change);
+        m_timestamp = m_buffer->timestamp();
+
         if (mode == InsertMode::Replace)
         {
-             if (pos == m_buffer->end())
-                 --pos;
-            sel.anchor() = pos.coord();
-            sel.cursor() = (str.empty() ?
-                pos : pos + str.byte_count_to(str.char_length() - 1)).coord();
-
-           // update following selections
-           auto changes = compute_modifications(*m_buffer, timestamp());
-           for (size_t j = index+1; j < m_selections.size(); ++j)
-           {
-               auto& sel = m_selections[j];
-               sel.anchor() = update_pos(changes, sel.anchor());
-               sel.cursor() = update_pos(changes, sel.cursor());
-           }
-           update_timestamp();
+            sel.anchor() = change.begin;
+            sel.cursor() = m_buffer->char_prev(change.end);
+        }
+        else
+        {
+            sel.anchor() = m_buffer->clamp(update_insert(sel.anchor(), change.begin, change.end));
+            sel.cursor() = m_buffer->clamp(update_insert(sel.cursor(), change.begin, change.end));
         }
     }
-    update();
     check_invariant();
     m_buffer->check_invariant();
 }
 
+void SelectionList::erase()
+{
+    update();
+    PositionChangesTracker changes_tracker;
+    for (auto& sel : m_selections)
+    {
+        changes_tracker.update_sel(sel);
+        auto pos = Kakoune::erase(*m_buffer, sel);
+        sel.anchor() = sel.cursor() = m_buffer->clamp(pos.coord());
+        changes_tracker.update(*m_buffer, m_timestamp);
+    }
+    avoid_eol();
+    m_buffer->check_invariant();
+}
+
+void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end)
+{
+    for (auto& sel : sels)
+    {
+        sel.anchor() = update_insert(sel.anchor(), begin, end);
+        sel.cursor() = update_insert(sel.cursor(), begin, end);
+    }
+}
+
+void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end)
+{
+    for (auto& sel : sels)
+    {
+        sel.anchor() = update_erase(sel.anchor(), begin, end);
+        sel.cursor() = update_erase(sel.cursor(), begin, end);
+    }
+}
 
 }
diff --git a/src/selection.hh b/src/selection.hh
index 75d26728..7e6fb2ad 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -165,8 +165,8 @@ private:
     size_t m_timestamp;
 };
 
-void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end);
-void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end, bool at_end);
+void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end);
+void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end);
 
 }
 

From fed2094e8967be0ee42787621af3a98b3b50e76e Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 26 May 2014 20:59:08 +0100
Subject: [PATCH 35/53] Revert "Remove line modification, replaced by
 modification"

This reverts commit a7540962cc90266f4f46858184b89f048364f9b2.
---
 src/line_modification.cc | 105 +++++++++++++++++++++++++++++++++++++++
 src/line_modification.hh |  26 ++++++++++
 2 files changed, 131 insertions(+)
 create mode 100644 src/line_modification.cc
 create mode 100644 src/line_modification.hh

diff --git a/src/line_modification.cc b/src/line_modification.cc
new file mode 100644
index 00000000..5da287fc
--- /dev/null
+++ b/src/line_modification.cc
@@ -0,0 +1,105 @@
+#include "line_modification.hh"
+
+#include "buffer.hh"
+
+namespace Kakoune
+{
+
+namespace
+{
+
+struct LineChange
+{
+    LineChange(const Buffer::Change& change)
+    {
+        ByteCoord begin = change.begin;
+        ByteCoord end = change.end;
+        if (change.type == Buffer::Change::Insert)
+        {
+            if (change.at_end and begin != ByteCoord{0,0})
+            {
+                kak_assert(begin.column == 0);
+                --begin.line;
+            }
+            pos = begin.line;
+            num = end.line - begin.line;
+        }
+        else
+        {
+            if (change.at_end and begin != ByteCoord{0,0})
+            {
+                kak_assert(begin.column == 0);
+                --begin.line;
+            }
+            pos = begin.line;
+            num = begin.line - end.line;
+        }
+    }
+
+    LineCount pos;
+    LineCount num;
+};
+
+}
+
+std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp)
+{
+    std::vector<LineModification> res;
+    for (auto& buf_change : buffer.changes_since(timestamp))
+    {
+        const LineChange change(buf_change);
+
+        auto pos = std::upper_bound(res.begin(), res.end(), change.pos,
+                                    [](const LineCount& l, const LineModification& c)
+                                    { return l < c.new_line; });
+
+        if (pos != res.begin())
+        {
+            auto& prev = *(pos-1);
+            if (change.pos <= prev.new_line + prev.num_added)
+                --pos;
+            else
+                pos = res.insert(pos, {change.pos - prev.diff(), change.pos, 0, 0});
+        }
+        else
+            pos = res.insert(pos, {change.pos, change.pos, 0, 0});
+
+        auto& modif = *pos;
+        auto next = pos + 1;
+        if (change.num > 0)
+        {
+            modif.num_added += change.num;
+            for (auto it = next; it != res.end(); ++it)
+                it->new_line += change.num;
+        }
+        if (change.num < 0)
+        {
+            const LineCount num_removed = -change.num;
+
+            auto delend = std::upper_bound(next, res.end(), change.pos + num_removed,
+                                           [](const LineCount& l, const LineModification& c)
+                                           { return l < c.new_line; });
+
+            for (auto it = next; it != delend; ++it)
+            {
+                LineCount removed_from_it = (change.pos + num_removed - it->new_line);
+                modif.num_removed += it->num_removed - std::min(removed_from_it, it->num_added);
+                modif.num_added += std::max(0_line, it->num_added - removed_from_it);
+            }
+            next = res.erase(next, delend);
+
+            const LineCount num_added_after_pos =
+                modif.new_line + modif.num_added - change.pos;
+            const LineCount num_removed_from_added =
+                std::min(num_removed, num_added_after_pos);
+            modif.num_added -= num_removed_from_added;
+            modif.num_removed += num_removed - num_removed_from_added;
+
+            for (auto it = next; it != res.end(); ++it)
+                it->new_line -= num_removed;
+        }
+    }
+    return res;
+}
+
+}
diff --git a/src/line_modification.hh b/src/line_modification.hh
new file mode 100644
index 00000000..3cd2d669
--- /dev/null
+++ b/src/line_modification.hh
@@ -0,0 +1,26 @@
+#ifndef line_change_watcher_hh_INCLUDED
+#define line_change_watcher_hh_INCLUDED
+
+#include "units.hh"
+#include "utils.hh"
+
+namespace Kakoune
+{
+
+class Buffer;
+
+struct LineModification
+{
+    LineCount old_line; // line position in the old buffer
+    LineCount new_line; // new line position
+    LineCount num_removed; // number of lines removed after this one
+    LineCount num_added; // number of lines added after this one
+
+    LineCount diff() const { return new_line - old_line + num_added - num_removed; }
+};
+
+std::vector<LineModification> compute_line_modifications(const Buffer& buffer, size_t timestamp);
+
+}
+
+#endif // line_change_watcher_hh_INCLUDED

From 19a5ed05a65596ec2d9928103c0afe9670d57fb5 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 26 May 2014 21:00:26 +0100
Subject: [PATCH 36/53] Revert "update Modification for WordDB"

This reverts commit 8f45623f98f187667b3842d432b1102b58e39037.

Conflicts:
	src/word_db.cc
---
 src/word_db.cc | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/word_db.cc b/src/word_db.cc
index b57b8d52..1ece5651 100644
--- a/src/word_db.cc
+++ b/src/word_db.cc
@@ -1,7 +1,7 @@
 #include "word_db.hh"
 
 #include "utils.hh"
-#include "modification.hh"
+#include "line_modification.hh"
 #include "utf8_iterator.hh"
 
 namespace Kakoune
@@ -64,7 +64,7 @@ void WordDB::update_db()
 {
     auto& buffer = *m_buffer;
 
-    auto modifs = compute_modifications(buffer, m_timestamp);
+    auto modifs = compute_line_modifications(buffer, m_timestamp);
     m_timestamp = buffer.timestamp();
 
     if (modifs.empty())
@@ -77,25 +77,25 @@ void WordDB::update_db()
     auto old_line = 0_line;
     for (auto& modif : modifs)
     {
-        kak_assert(0_line <= modif.new_coord.line and
-                   modif.new_coord.line < buffer.line_count());
-
-        // copy unchanged lines between last modification and this one
-        while (old_line < modif.old_coord.line)
+        kak_assert(0_line <= modif.new_line and modif.new_line < buffer.line_count());
+        kak_assert(old_line <= modif.old_line);
+        while (old_line < modif.old_line)
             new_lines.push_back(std::move(m_line_to_words[(int)old_line++]));
 
-        // remove words from removed lines
-        while (old_line <= modif.old_coord.line + modif.num_removed.line
-               and old_line < m_line_to_words.size())
-            remove_words(m_words, m_line_to_words[(int)old_line++]);
+        kak_assert((int)new_lines.size() == (int)modif.new_line);
 
-        // add words from new lines
-        for (auto l = 0_line; l <= modif.num_added.line; ++l)
+        while (old_line <= modif.old_line + modif.num_removed)
         {
-            if (modif.new_coord.line + l >= buffer.line_count())
+            kak_assert(old_line < m_line_to_words.size());
+            remove_words(m_words, m_line_to_words[(int)old_line++]);
+        }
+
+        for (auto l = 0_line; l <= modif.num_added; ++l)
+        {
+            if (modif.new_line + l >= buffer.line_count())
                 break;
 
-            new_lines.push_back(get_words(buffer[modif.new_coord.line + l]));
+            new_lines.push_back(get_words(buffer[modif.new_line + l]));
             add_words(m_words, new_lines.back());
         }
     }

From ce469398c516420f7ab629006ee02c028e82ebf6 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 26 May 2014 21:01:45 +0100
Subject: [PATCH 37/53] Revert "Use Modification for region highlighter"

This reverts commit aa64851de622921751741d39092e7cf14fe28649.

Conflicts:
	src/highlighters.cc
---
 src/highlighters.cc | 34 ++++++++++++++--------------------
 1 file changed, 14 insertions(+), 20 deletions(-)

diff --git a/src/highlighters.cc b/src/highlighters.cc
index f5b4faa2..a51f764e 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -5,7 +5,7 @@
 #include "color_registry.hh"
 #include "context.hh"
 #include "display_buffer.hh"
-#include "modification.hh"
+#include "line_modification.hh"
 #include "option_types.hh"
 #include "register_manager.hh"
 #include "string.hh"
@@ -721,7 +721,7 @@ private:
         }
         else
         {
-            auto modifs = compute_modifications(buffer, cache.timestamp);
+            auto modifs = compute_line_modifications(buffer, cache.timestamp);
             update_matches(buffer, modifs, cache.begin_matches, m_begin);
             update_matches(buffer, modifs, cache.end_matches, m_end);
         }
@@ -762,28 +762,26 @@ private:
         }
     }
 
-    void update_matches(const Buffer& buffer, memoryview<Modification> modifs, MatchList& matches, const Regex& regex)
+    void update_matches(const Buffer& buffer, memoryview<LineModification> modifs, MatchList& matches, const Regex& regex)
     {
         const size_t buf_timestamp = buffer.timestamp();
         // remove out of date matches and update line for others
         auto ins_pos = matches.begin();
         for (auto it = ins_pos; it != matches.end(); ++it)
         {
-            const ByteCoord pos{ it->line, it->begin };
-            auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
-                                             [](const ByteCoord& c, const Modification& m)
-                                             { return c < m.old_coord; });
+            auto modif_it = std::lower_bound(modifs.begin(), modifs.end(), it->line,
+                                             [](const LineModification& c, const LineCount& l)
+                                             { return c.old_line < l; });
             bool erase = false;
             if (modif_it != modifs.begin())
             {
                 auto& prev = *(modif_it-1);
-                erase = it->line <= prev.old_coord.line + prev.num_removed.line;
-                it->line += prev.new_coord.line - prev.old_coord.line +
-                            prev.num_added.line - prev.num_removed.line;
+                erase = it->line <= prev.old_line + prev.num_removed;
+                it->line += prev.diff();
             }
-            if (modif_it != modifs.end() and modif_it->new_coord.line == it->line)
+            if (modif_it != modifs.end() and modif_it->old_line == it->line)
                 erase = true;
-            kak_assert(it->line < buffer.line_count());
+            erase = erase or (it->line >= buffer.line_count());
 
             if (not erase)
             {
@@ -802,24 +800,20 @@ private:
         size_t pivot = matches.size();
 
         // try to find new matches in each updated lines
-        LineCount last_line = -1;
         for (auto& modif : modifs)
         {
-            for (auto line = std::max(last_line + 1, modif.new_coord.line);
-                 line <= modif.new_coord.line + modif.num_added.line and
-                 line < buffer.line_count();
-                 ++line)
+            for (auto line = modif.new_line;
+                 line < modif.new_line + modif.num_added+1 and
+                 line < buffer.line_count(); ++line)
             {
                 auto& l = buffer[line];
-                using RegexIt = boost::regex_iterator<String::const_iterator>;
-                for (RegexIt it{l.begin(), l.end(), regex}, end; it != end; ++it)
+                for (boost::regex_iterator<String::const_iterator> it{l.begin(), l.end(), regex}, end{}; it != end; ++it)
                 {
                     ByteCount b = (int)((*it)[0].first - l.begin());
                     ByteCount e = (int)((*it)[0].second - l.begin());
                     matches.push_back({ buf_timestamp, line, b, e });
                 }
             }
-            last_line = modif.new_coord.line + modif.num_added.line;
         }
         std::inplace_merge(matches.begin(), matches.begin() + pivot, matches.end(),
                            compare_matches_begin);

From 9870ac22f6a22cc9a87a98a662f1e442500ca256 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 26 May 2014 21:09:12 +0100
Subject: [PATCH 38/53] Remove Modification

Lets consider that as a failed experiment.

You see, I learned something today, for a complicated problem, it
is important to keep as much knowledge of the exact problem as
possible. the Modification approach failed because it tried to
solve the general problem, which is quite complex. The new approach,
which keeps the knowledge that selections are sorted is much simpler
and faster (see f49bec802157fc592bc6e35755807c6c3a531e78).
---
 src/modification.cc | 232 --------------------------------------------
 src/modification.hh |  33 -------
 src/normal.cc       |   1 -
 src/unit_tests.cc   | 141 ---------------------------
 4 files changed, 407 deletions(-)
 delete mode 100644 src/modification.cc
 delete mode 100644 src/modification.hh

diff --git a/src/modification.cc b/src/modification.cc
deleted file mode 100644
index ba22a373..00000000
--- a/src/modification.cc
+++ /dev/null
@@ -1,232 +0,0 @@
-#include "modification.hh"
-
-#include "buffer.hh"
-
-namespace Kakoune
-{
-
-namespace
-{
-
-ByteCount change_added_column(const Buffer::Change& change)
-{
-    kak_assert(change.type == Buffer::Change::Insert);
-    if (change.begin.line == change.end.line)
-        return change.end.column - change.begin.column;
-    else
-        return change.end.column;
-}
-
-}
-
-ByteCoord Modification::added_end() const
-{
-    if (num_added.line)
-        return { new_coord.line + num_added.line, num_added.column };
-    else
-        return { new_coord.line, new_coord.column + num_added.column };
-}
-
-ByteCoord Modification::removed_end() const
-{
-    if (num_removed.line)
-        return { old_coord.line + num_removed.line, num_removed.column };
-    else
-        return { old_coord.line, old_coord.column + num_removed.column };
-}
-
-ByteCoord Modification::get_old_coord(ByteCoord coord) const
-{
-    Modification inverse = { new_coord, old_coord, num_added, num_removed };
-    return inverse.get_new_coord(coord);
-}
-
-ByteCoord Modification::get_new_coord(ByteCoord coord) const
-{
-    if (coord < old_coord)
-        return coord;
-
-    // apply remove
-    if (coord < removed_end())
-        coord = old_coord;
-    else if (coord.line == old_coord.line + num_removed.line)
-    {
-        coord.line = old_coord.line;
-        if (num_removed.line != 0)
-            coord.column += old_coord.column;
-        coord.column -= num_removed.column;
-    }
-    else
-        coord.line -= num_removed.line;
-
-    // apply move
-    coord.line += new_coord.line - old_coord.line;
-    if (coord.line == new_coord.line)
-        coord.column += new_coord.column - old_coord.column;
-
-    // apply add
-    if (coord.line == new_coord.line)
-    {
-        if (num_added.line == 0)
-            coord.column += num_added.column;
-        else
-            coord.column += num_added.column - new_coord.column;
-    }
-    coord.line += num_added.line;
-
-    return coord;
-}
-
-std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes)
-{
-    std::vector<Modification> res;
-    for (auto& change : changes)
-    {
-        auto pos = std::upper_bound(res.begin(), res.end(), change.begin,
-                                    [](const ByteCoord& l, const Modification& c)
-                                    { return l < c.new_coord; });
-
-        if (pos != res.begin())
-        {
-            auto& prev = *(pos-1);
-            if (change.begin <= prev.added_end())
-                --pos;
-            else
-                pos = res.insert(pos, {prev.get_old_coord(change.begin), change.begin, {}, {}});
-        }
-        else
-            pos = res.insert(pos, {change.begin, change.begin, {}, {}});
-
-        auto& modif = *pos;
-        auto next = pos + 1;
-        if (change.type == Buffer::Change::Insert)
-        {
-            const LineCount last_line = modif.new_coord.line + modif.num_added.line;
-
-            modif.num_added.line += change.end.line - change.begin.line;
-
-            if (change.begin.line == last_line)
-            {
-                if (change.end.line == change.begin.line)
-                    modif.num_added.column += change.end.column - change.begin.column;
-                else
-                    modif.num_added.column = change.end.column;
-                kak_assert(modif.num_added.column >= 0);
-            }
-
-            for (auto it = next; it != res.end(); ++it)
-            {
-                if (it->new_coord.line == change.begin.line)
-                    it->new_coord.column += change.end.column - change.begin.column;
-                it->new_coord.line += change.end.line - change.begin.line;
-
-#ifdef KAK_DEBUG
-                auto ref_new_coord = (it-1)->get_new_coord(it->old_coord);
-                kak_assert(it->new_coord == ref_new_coord);
-#endif
-            }
-        }
-        else
-        {
-            ByteCoord num_removed = { change.end.line - change.begin.line, 0 };
-            if (num_removed.line != 0)
-                num_removed.column = change.end.column;
-            else
-                num_removed.column = change.end.column - change.begin.column;
-
-            ByteCoord num_added;
-
-            // merge modifications lying in the erased range.
-            auto delend = std::upper_bound(next, res.end(), change.end,
-                                           [](const ByteCoord& l, const Modification& c)
-                                           { return l < c.new_coord; });
-
-            for (auto it = next; it != delend; ++it)
-            {
-                {
-                    LineCount removed_from_it = change.end.line - it->new_coord.line;
-                    num_removed.line += it->num_removed.line - std::min(removed_from_it, it->num_added.line);
-                    num_added.line += std::max(0_line, it->num_added.line - removed_from_it);
-                }
-
-                if (it->new_coord.line == change.end.line)
-                    num_removed.column += it->num_removed.column;
-                if (it->new_coord.line + it->num_added.line == change.end.line)
-                {
-                    ByteCount removed_from_added = std::min(num_removed.column, it->num_added.column);
-                    num_added.column += std::max(0_byte, it->num_added.column - removed_from_added);
-                    num_removed.column -= removed_from_added;
-                }
-                if (it->new_coord.line == change.begin.line)
-                    num_removed.column += it->new_coord.column - change.begin.column;
-            }
-            next = res.erase(next, delend);
-
-            // update modification with changes
-            if (change.end.line == modif.new_coord.line + modif.num_added.line)
-            {
-                ByteCount removed_from_added = std::min(num_removed.column, modif.num_added.column);
-                modif.num_added.column = std::max(0_byte, modif.num_added.column - removed_from_added) + num_added.column;
-                modif.num_removed.column += num_removed.column - removed_from_added;
-            }
-            else if (change.end.line > modif.new_coord.line + modif.num_added.line)
-            {
-                modif.num_added.column = num_added.column;
-                modif.num_removed.column = num_removed.column;
-            }
-            if (change.begin.line == modif.new_coord.line)
-                modif.num_added.column += change.begin.column - modif.new_coord.column;
-
-            {
-                LineCount change_pos_in_modif = change.begin.line - modif.new_coord.line;
-                LineCount removed_from_added = std::min(num_removed.line, modif.num_added.line - change_pos_in_modif);
-                modif.num_added.line = std::max(0_line, modif.num_added.line - removed_from_added) + num_added.line;
-                modif.num_removed.line += num_removed.line - removed_from_added;
-            }
-
-            for (auto it = next; it != res.end(); ++it)
-            {
-                if (it->new_coord.line == change.end.line)
-                    it->new_coord.column += change.begin.column - change.end.column;
-                it->new_coord.line += change.begin.line - change.end.line;
-
-#ifdef KAK_DEBUG
-                auto ref_new_coord = (it-1)->get_new_coord(it->old_coord);
-                kak_assert(it->new_coord == ref_new_coord);
-#endif
-            }
-        }
-    }
-
-#ifdef KAK_DEBUG
-    for (size_t i = 0; i+1 < res.size(); ++i)
-    {
-        auto old_coord = res[i].get_old_coord(res[i+1].new_coord);
-        kak_assert(res[i+1].old_coord == old_coord);
-        auto new_coord = res[i].get_new_coord(res[i+1].old_coord);
-        kak_assert(res[i+1].new_coord == new_coord);
-    }
-#endif
-
-    return res;
-}
-
-std::vector<Modification> compute_modifications(const Buffer& buffer, size_t timestamp)
-{
-    return compute_modifications(buffer.changes_since(timestamp));
-}
-
-ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos)
-{
-    auto modif_it = std::upper_bound(modifs.begin(), modifs.end(), pos,
-                                     [](const ByteCoord& c, const Modification& m)
-                                     { return c < m.old_coord; });
-    if (modif_it != modifs.begin())
-    {
-        auto& prev = *(modif_it-1);
-        return prev.get_new_coord(pos);
-    }
-    return pos;
-}
-
-}
diff --git a/src/modification.hh b/src/modification.hh
deleted file mode 100644
index 2b972a84..00000000
--- a/src/modification.hh
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef modification_hh_INCLUDED
-#define modification_hh_INCLUDED
-
-#include "coord.hh"
-#include "utils.hh"
-#include "buffer.hh"
-
-namespace Kakoune
-{
-
-struct Modification
-{
-    ByteCoord old_coord;
-    ByteCoord new_coord;
-    ByteCoord num_removed;
-    ByteCoord num_added;
-
-    ByteCoord added_end() const;
-    ByteCoord removed_end() const;
-
-    ByteCoord get_old_coord(ByteCoord coord) const;
-    ByteCoord get_new_coord(ByteCoord coord) const;
-};
-
-std::vector<Modification> compute_modifications(const Buffer& buffer, size_t timestamp);
-std::vector<Modification> compute_modifications(memoryview<Buffer::Change> changes);
-
-ByteCoord update_pos(memoryview<Modification> modifs, ByteCoord pos);
-
-
-}
-
-#endif // modification_hh_INCLUDED
diff --git a/src/normal.cc b/src/normal.cc
index 62cfb864..2e7e166e 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -17,7 +17,6 @@
 #include "user_interface.hh"
 #include "utf8_iterator.hh"
 #include "debug.hh"
-#include "modification.hh"
 
 namespace Kakoune
 {
diff --git a/src/unit_tests.cc b/src/unit_tests.cc
index c7569804..85038d06 100644
--- a/src/unit_tests.cc
+++ b/src/unit_tests.cc
@@ -4,8 +4,6 @@
 #include "selectors.hh"
 #include "word_db.hh"
 
-#include "modification.hh"
-
 using namespace Kakoune;
 
 void test_buffer()
@@ -144,144 +142,6 @@ void test_keys()
     kak_assert(keys == parsed_keys);
 }
 
-void test_modification()
-{
-    {
-        Modification modif = { {5, 10}, {5, 10}, {0, 0}, {4, 17} };
-        auto pos = modif.get_new_coord({5, 10});
-        kak_assert(pos == ByteCoord{9 COMMA 17});
-    }
-    {
-        Modification modif = { {7, 10}, {7, 10}, {0, 5}, {0, 0} };
-        auto pos = modif.get_new_coord({7, 10});
-        kak_assert(pos == ByteCoord{7 COMMA 10});
-    }
-    {
-        Modification modif = { {8, 0}, {8, 0}, {1, 0}, {1, 0} };
-        auto pos = modif.get_new_coord({12, 31});
-        kak_assert(pos == ByteCoord{12 COMMA 31});
-    }
-    {
-        Modification modif = { {0, 7}, {0, 8}, {0, 0}, {0, 1} };
-        auto pos = modif.get_new_coord({1, 0});
-        kak_assert(pos == ByteCoord{1 COMMA 0});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Insert, {1, 0}, {5, 161}, false },
-            { Buffer::Change::Insert, {5, 161}, {30, 0}, false },
-            { Buffer::Change::Insert, {30, 0}, {35, 0}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 1);
-        auto& modif = modifs[0];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 0});
-        kak_assert(modif.new_coord == ByteCoord{1 COMMA 0});
-        kak_assert(modif.num_added == ByteCoord{34 COMMA 0});
-        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Insert, {1, 20}, {2, 0}, false },
-            { Buffer::Change::Insert, {1, 10}, {2, 0}, false },
-            { Buffer::Change::Insert, {1, 0},  {2, 0}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 3);
-        auto& modif = modifs[2];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 20});
-        kak_assert(modif.new_coord == ByteCoord{3 COMMA 10});
-        kak_assert(modif.num_added == ByteCoord{1 COMMA 0});
-        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Erase, {1, 10}, {2, 0}, false },
-            { Buffer::Change::Erase, {0, 10}, {1, 0}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 2);
-        auto& modif = modifs[1];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 10});
-        kak_assert(modif.new_coord == ByteCoord{0 COMMA 20});
-        kak_assert(modif.num_added == ByteCoord{0 COMMA 0});
-        kak_assert(modif.num_removed == ByteCoord{1 COMMA 0});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Insert, {1, 10}, {2, 0}, false },
-            { Buffer::Change::Erase, {1, 20}, {2, 10}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 1);
-        auto& modif = modifs[0];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 10});
-        kak_assert(modif.new_coord == ByteCoord{1 COMMA 10});
-        kak_assert(modif.num_added == ByteCoord{0 COMMA 10});
-        kak_assert(modif.num_removed == ByteCoord{0 COMMA 10});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Insert, {1, 10}, {2, 20}, false },
-            { Buffer::Change::Erase, {1, 5}, {2, 10}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 1);
-        auto& modif = modifs[0];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 5});
-        kak_assert(modif.new_coord == ByteCoord{1 COMMA 5});
-        kak_assert(modif.num_added == ByteCoord{0 COMMA 10});
-        kak_assert(modif.num_removed == ByteCoord{0 COMMA 5});
-    }
-    {
-        std::vector<Buffer::Change> change = {
-            { Buffer::Change::Insert, {1, 10}, {2, 20}, false },
-            { Buffer::Change::Erase, {1, 5}, {2, 10}, false },
-            { Buffer::Change::Erase, {1, 10}, {2, 0}, false },
-        };
-        auto modifs = compute_modifications(change);
-        kak_assert(modifs.size() == 1);
-        auto& modif = modifs[0];
-        kak_assert(modif.old_coord == ByteCoord{1 COMMA 5});
-        kak_assert(modif.new_coord == ByteCoord{1 COMMA 5});
-        kak_assert(modif.num_added == ByteCoord{0 COMMA 5});
-        kak_assert(modif.num_removed == ByteCoord{1 COMMA 0});
-    }
-
-    Buffer buffer("test", Buffer::Flags::None,
-                  { "tchou mutch\n",
-                    "tchou kanaky tchou\n",
-                    "\n",
-                    "tchaa tchaa\n",
-                    "allo\n"});
-
-    size_t timestamp = buffer.timestamp();
-
-    buffer.erase(buffer.iterator_at({0,0}), buffer.iterator_at({3,0}));
-    buffer.insert(buffer.iterator_at({0,0}), "youuhou\nniahaha");
-
-    buffer.insert(buffer.iterator_at({2,4}), "yeehaah\n");
-
-    auto modifs = compute_modifications(buffer, timestamp);
-    kak_assert(modifs.size() == 2);
-    {
-        auto& modif = modifs[0];
-        kak_assert(modif.old_coord == ByteCoord{0 COMMA 0});
-        kak_assert(modif.new_coord == ByteCoord{0 COMMA 0});
-        kak_assert(modif.num_added == ByteCoord{1 COMMA 7});
-        kak_assert(modif.num_removed == ByteCoord{3 COMMA 0});
-        auto new_coord = modif.get_new_coord({1, 10});
-        kak_assert(new_coord == ByteCoord{1 COMMA 7});
-    }
-    {
-        auto& modif = modifs[1];
-        kak_assert(modif.old_coord == ByteCoord{4 COMMA 4});
-        kak_assert(modif.new_coord == ByteCoord{2 COMMA 4});
-        kak_assert(modif.num_added == ByteCoord{1 COMMA 0});
-        kak_assert(modif.num_removed == ByteCoord{0 COMMA 0});
-    }
-}
-
 void run_unit_tests()
 {
     test_utf8();
@@ -289,6 +149,5 @@ void run_unit_tests()
     test_keys();
     test_buffer();
     test_undo_group_optimizer();
-    test_modification();
     test_word_db();
 }

From 49ab0c101a1cef1a5c57e4e2dec3160309510d7a Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Thu, 29 May 2014 05:48:40 +0100
Subject: [PATCH 39/53] Use forward iteration on selections, and take advantage
 of it when updating

SelectionList::update now is optimized for the common case where changes
are sorted, the algorithm is O(m*n) with m the number of sorted ranges
in the changes. In the common case, m should be very small.
---
 src/input_handler.cc |  97 +++++++++++++++----------------
 src/normal.cc        |   2 +
 src/selection.cc     | 134 +++++++++++++++++++++++++------------------
 src/selection.hh     |   7 ++-
 4 files changed, 133 insertions(+), 107 deletions(-)

diff --git a/src/input_handler.cc b/src/input_handler.cc
index 60cfb618..d5312305 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -669,21 +669,23 @@ public:
         }
         else if (key == Key::Backspace)
         {
-            for (auto& sel : reversed(context().selections()))
+            std::vector<Selection> sels;
+            for (auto& sel : context().selections())
             {
                 if (sel.cursor() == ByteCoord{0,0})
                     continue;
-                auto pos = buffer.iterator_at(sel.cursor());
-                buffer.erase(utf8::previous(pos), pos);
+                auto pos = sel.cursor();
+                sels.push_back({ buffer.char_prev(pos) });
             }
+            if (not sels.empty())
+                SelectionList{buffer, std::move(sels)}.erase();
         }
         else if (key == Key::Delete)
         {
-            for (auto& sel : reversed(context().selections()))
-            {
-                auto pos = buffer.iterator_at(sel.cursor());
-                buffer.erase(pos, utf8::next(pos));
-            }
+            std::vector<Selection> sels;
+            for (auto& sel : context().selections())
+                sels.push_back({ sel.cursor() });
+            SelectionList{buffer, std::move(sels)}.erase();
         }
         else if (key == Key::Left)
         {
@@ -774,60 +776,55 @@ private:
         SelectionList& selections = context().selections();
         Buffer& buffer = context().buffer();
 
-        for (auto& sel : reversed(selections))
+        switch (mode)
         {
-            ByteCoord anchor, cursor;
-            switch (mode)
+        case InsertMode::Insert:
+            for (auto& sel : selections)
+                sel = Selection{sel.max(), sel.min()};
+            break;
+        case InsertMode::Replace:
+            selections.erase();
+            break;
+        case InsertMode::Append:
+            for (auto& sel : selections)
             {
-            case InsertMode::Insert:
-                anchor = sel.max();
-                cursor = sel.min();
-                break;
-            case InsertMode::Replace:
-                anchor = cursor = Kakoune::erase(buffer, sel).coord();
-                break;
-            case InsertMode::Append:
-                anchor = sel.min();
-                cursor = sel.max();
+                sel = Selection{sel.min(), sel.max()};
+                auto& cursor = sel.cursor();
                 // special case for end of lines, append to current line instead
                 if (cursor.column != buffer[cursor.line].length() - 1)
                     cursor = buffer.char_next(cursor);
-                break;
+            }
+            break;
 
-            case InsertMode::OpenLineBelow:
-            case InsertMode::AppendAtLineEnd:
-                anchor = cursor = ByteCoord{sel.max().line, buffer[sel.max().line].length() - 1};
-                break;
+        case InsertMode::OpenLineBelow:
+        case InsertMode::AppendAtLineEnd:
+            for (auto& sel : selections)
+                sel = ByteCoord{sel.max().line, buffer[sel.max().line].length() - 1};
+            break;
 
-            case InsertMode::OpenLineAbove:
-            case InsertMode::InsertAtLineBegin:
-                anchor = sel.min().line;
+        case InsertMode::OpenLineAbove:
+        case InsertMode::InsertAtLineBegin:
+            for (auto& sel : selections)
+            {
+                ByteCoord pos = sel.min().line;
                 if (mode == InsertMode::OpenLineAbove)
-                    anchor = buffer.char_prev(anchor);
+                    pos = buffer.char_prev(pos);
                 else
                 {
-                    auto anchor_non_blank = buffer.iterator_at(anchor);
-                    while (*anchor_non_blank == ' ' or *anchor_non_blank == '\t')
-                        ++anchor_non_blank;
-                    if (*anchor_non_blank != '\n')
-                        anchor = anchor_non_blank.coord();
+                    auto pos_non_blank = buffer.iterator_at(pos);
+                    while (*pos_non_blank == ' ' or *pos_non_blank == '\t')
+                        ++pos_non_blank;
+                    if (*pos_non_blank != '\n')
+                        pos = pos_non_blank.coord();
                 }
-                cursor = anchor;
-                break;
-            case InsertMode::InsertAtNextLineBegin:
-            case InsertMode::InsertCursor:
-                 kak_assert(false); // not implemented
-                 break;
+                sel = pos;
             }
-            if (buffer.is_end(anchor))
-               anchor = buffer.char_prev(anchor);
-            if (buffer.is_end(cursor))
-               cursor = buffer.char_prev(cursor);
-
-            sel.anchor() = anchor;
-            sel.cursor() = cursor;
+            break;
+        case InsertMode::InsertAtNextLineBegin:
+        case InsertMode::InsertCursor:
+             kak_assert(false); // not implemented
+             break;
         }
-        selections.update();
         if (mode == InsertMode::OpenLineBelow or mode == InsertMode::OpenLineAbove)
         {
             insert('\n');
@@ -837,7 +834,7 @@ private:
                 {
                     // special case, the --first line above did nothing, so we need to compensate now
                     if (sel.anchor() == buffer.char_next({0,0}))
-                        sel.anchor() = sel.cursor() = ByteCoord{0,0};
+                        sel = Selection{{0,0}};
                 }
             }
         }
diff --git a/src/normal.cc b/src/normal.cc
index 223d5075..cc7eaa88 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -463,6 +463,7 @@ void erase_selections(Context& context, int)
     RegisterManager::instance()['"'] = context.selections_content();
     ScopedEdition edition(context);
     context.selections().erase();
+    context.selections().avoid_eol();
 }
 
 void cat_erase_selections(Context& context, int)
@@ -473,6 +474,7 @@ void cat_erase_selections(Context& context, int)
         str += sel;
     RegisterManager::instance()['"'] = memoryview<String>(str);
     context.selections().erase();
+    context.selections().avoid_eol();
 }
 
 
diff --git a/src/selection.cc b/src/selection.cc
index d3c798b0..a1bd8cbc 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -67,10 +67,60 @@ ByteCoord update_pos(ByteCoord coord, const Buffer::Change& change)
 {
     if (change.type == Buffer::Change::Insert)
         return update_insert(coord, change.begin, change.end);
-    else  
+    else
         return update_erase(coord, change.begin, change.end);
 }
 
+// This tracks position changes for changes that are done
+// in a forward way (each change takes place at a position)
+// *after* the previous one.
+struct PositionChangesTracker
+{
+    ByteCoord last_pos;
+    ByteCoord pos_change;
+
+    void update(const Buffer::Change& change)
+    {
+        if (change.type == Buffer::Change::Insert)
+        {
+            pos_change.line += change.end.line - change.begin.line;
+            if (change.begin.line != last_pos.line)
+                pos_change.column = 0;
+            pos_change.column += change.end.column - change.begin.column;
+            last_pos = change.end;
+        }
+        else if (change.type == Buffer::Change::Erase)
+        {
+            pos_change.line -= change.end.line - change.begin.line;
+            if (last_pos.line != change.end.line)
+                pos_change.column = 0;
+            pos_change.column -= change.end.column - change.begin.column;
+            last_pos = change.begin;
+        }
+    }
+
+    void update(const Buffer& buffer, size_t& timestamp)
+    {
+        for (auto& change : buffer.changes_since(timestamp))
+            update(change);
+        timestamp = buffer.timestamp();
+    }
+
+    ByteCoord get_new_coord(ByteCoord coord)
+    {
+        if (last_pos.line - pos_change.line == coord.line)
+            coord.column += pos_change.column;
+        coord.line += pos_change.line;
+        return coord;
+    }
+
+    void update_sel(Selection& sel)
+    {
+        sel.anchor() = get_new_coord(sel.anchor());
+        sel.cursor() = get_new_coord(sel.cursor());
+    }
+};
+
 }
 
 void SelectionList::update()
@@ -78,13 +128,38 @@ void SelectionList::update()
     if (m_timestamp == m_buffer->timestamp())
         return;
 
-    for (auto& change : m_buffer->changes_since(m_timestamp))
+    auto compare = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
+        { return lhs.begin < rhs.begin; };
+    auto relevant = [](const Buffer::Change& change, const ByteCoord& coord)
+        { return change.type == Buffer::Change::Insert ? change.begin <= coord
+                                                       : change.begin < coord; };
+
+    auto changes = m_buffer->changes_since(m_timestamp);
+    auto change_it = changes.begin();
+    while (change_it != changes.end())
     {
+        auto change_end = std::is_sorted_until(change_it, changes.end(), compare);
+        PositionChangesTracker changes_tracker;
+
+        auto advance_while_relevant = [&](const ByteCoord& pos) mutable {
+            while (relevant(*change_it, pos) and change_it != change_end)
+                changes_tracker.update(*change_it++);
+            while (change_it != change_end and
+                  change_it->begin == changes_tracker.last_pos)
+                changes_tracker.update(*change_it++);
+        };
+
         for (auto& sel : m_selections)
         {
-            sel.anchor() = update_pos(sel.anchor(), change);
-            sel.cursor() = update_pos(sel.cursor(), change);
+            auto& sel_min = sel.min();
+            auto& sel_max = sel.max();
+            advance_while_relevant(sel_min);
+            sel_min = changes_tracker.get_new_coord(sel_min);
+
+            advance_while_relevant(sel_max);
+            sel_max = changes_tracker.get_new_coord(sel_max);
         }
+        change_it = change_end;
     }
     for (auto& sel : m_selections)
     {
@@ -193,56 +268,6 @@ BufferIterator prepare_insert(Buffer& buffer, const Selection& sel, InsertMode m
     return {};
 }
 
-// This tracks position changes for changes that are done
-// in a forward way (each change takes place at a position)
-// *after* the previous one.
-struct PositionChangesTracker 
-{
-    ByteCoord last_pos;
-    ByteCoord pos_change;
-
-    void update(const Buffer::Change& change)
-    {
-        if (change.type == Buffer::Change::Insert)
-        {
-            pos_change.line += change.end.line - change.begin.line;
-            if (change.begin.line != last_pos.line)
-                pos_change.column = 0;
-            pos_change.column += change.end.column - change.begin.column;
-            last_pos = change.end;
-        }
-        else if (change.type == Buffer::Change::Erase)
-        {
-            pos_change.line -= change.end.line - change.begin.line;
-            if (last_pos.line != change.end.line)
-                pos_change.column = 0;
-            pos_change.column -= change.end.column - change.begin.column;
-            last_pos = change.begin;
-        }
-    }
-
-    void update(const Buffer& buffer, size_t& timestamp)
-    {
-        for (auto& change : buffer.changes_since(timestamp))
-            update(change);
-        timestamp = buffer.timestamp();
-    }
-
-    ByteCoord get_new_coord(ByteCoord coord)
-    {
-        if (last_pos.line - pos_change.line == coord.line)
-            coord.column += pos_change.column;
-        coord.line += pos_change.line;
-        return coord;
-    }
-
-    void update_sel(Selection& sel)
-    {
-        sel.anchor() = get_new_coord(sel.anchor());
-        sel.cursor() = get_new_coord(sel.cursor());
-    }
-};
-
 void SelectionList::insert(memoryview<String> strings, InsertMode mode)
 {
     if (strings.empty())
@@ -294,7 +319,6 @@ void SelectionList::erase()
         sel.anchor() = sel.cursor() = m_buffer->clamp(pos.coord());
         changes_tracker.update(*m_buffer, m_timestamp);
     }
-    avoid_eol();
     m_buffer->check_invariant();
 }
 
diff --git a/src/selection.hh b/src/selection.hh
index 7e6fb2ad..651ee3fd 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -34,8 +34,11 @@ struct Selection
         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
     }
 
-    const ByteCoord& min() const { return std::min(m_anchor, m_cursor); }
-    const ByteCoord& max() const { return std::max(m_anchor, m_cursor); }
+    const ByteCoord& min() const { return m_anchor < m_cursor ? m_anchor : m_cursor; }
+    const ByteCoord& max() const { return m_anchor < m_cursor ? m_cursor : m_anchor; }
+
+    ByteCoord& min() { return m_anchor < m_cursor ? m_anchor : m_cursor; }
+    ByteCoord& max() { return m_anchor < m_cursor ? m_cursor : m_anchor; }
 
 private:
     ByteCoord m_anchor;

From 321e770565ff92db4dca9f6356f820c034156b6b Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 31 May 2014 11:51:58 +0100
Subject: [PATCH 40/53] update TODO

---
 TODO | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/TODO b/TODO
index 3f4cecd5..127ef8b0 100644
--- a/TODO
+++ b/TODO
@@ -60,16 +60,6 @@
   the interpreters, regex for finding used kak variables (ability to
   add direct python/perl/ruby/whatever evaluation).
 
-* Optimize BufferModificationListener behaviour:
-
-  - Editor should modify in reverse order, as a modification at one point does not
-    impact the position of selections before it, so applying modification in reverse
-    order removes the needs to have selection updated on the fly, and permit deferred
-    update.
-
-  - Accumulate all the modifications and update the selections with the
-    whole knowledge -> try to remove this O(n2) behaviour.
-
 * User defined text objects
 
 * multiple parameters support for normal mode commands ?

From 9006b31472816a64056a782c0968e14b4085d9a8 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 31 May 2014 11:56:48 +0100
Subject: [PATCH 41/53] remove reverse iterator from SelectionList

---
 src/selection.hh | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/selection.hh b/src/selection.hh
index 651ee3fd..652a558f 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -111,10 +111,6 @@ struct SelectionList
     iterator begin() { return m_selections.begin(); }
     iterator end() { return m_selections.end(); }
 
-    using reverse_iterator = std::vector<Selection>::reverse_iterator;
-    reverse_iterator rbegin() { return m_selections.rbegin(); }
-    reverse_iterator rend() { return m_selections.rend(); }
-
     using const_iterator = std::vector<Selection>::const_iterator;
     const_iterator begin() const { return m_selections.begin(); }
     const_iterator end() const { return m_selections.end(); }

From cf03cc97ef201c4b80a057055f9889df20009dc3 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 31 May 2014 18:12:54 +0100
Subject: [PATCH 42/53] formatting fix

---
 src/selection.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/selection.cc b/src/selection.cc
index a1bd8cbc..b45c1898 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -145,7 +145,7 @@ void SelectionList::update()
             while (relevant(*change_it, pos) and change_it != change_end)
                 changes_tracker.update(*change_it++);
             while (change_it != change_end and
-                  change_it->begin == changes_tracker.last_pos)
+                   change_it->begin == changes_tracker.last_pos)
                 changes_tracker.update(*change_it++);
         };
 

From 5bcb55b6ddf82c26bb9d08c433c68246cc7bc625 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sat, 31 May 2014 18:18:29 +0100
Subject: [PATCH 43/53] minor cleanups in insert_completer.cc

---
 src/insert_completer.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/insert_completer.cc b/src/insert_completer.cc
index 2feddbb6..27342245 100644
--- a/src/insert_completer.cc
+++ b/src/insert_completer.cc
@@ -203,8 +203,8 @@ void InsertCompleter::select(int offset)
             const_cast<SelectionList&>(selections).update();
         }
     }
-    m_completions.end   = cursor_pos;
-    m_completions.begin = buffer.advance(m_completions.end, -candidate.length());
+    m_completions.end = cursor_pos;
+    m_completions.begin = buffer.advance(cursor_pos, -candidate.length());
     m_completions.timestamp = buffer.timestamp();
     if (m_context.has_ui())
         m_context.ui().menu_select(m_current_candidate);
@@ -227,8 +227,8 @@ void InsertCompleter::update()
         ByteCoord cursor = m_context.selections().main().cursor();
         ByteCoord compl_beg = m_completions.begin;
         if (cursor.line == compl_beg.line and
-            is_in_range(cursor.column - compl_beg.column,
-                        ByteCount{0}, longest_completion-1))
+            is_in_range(cursor.column, compl_beg.column,
+                        compl_beg.column + longest_completion-1))
         {
             String prefix = m_context.buffer().string(compl_beg, cursor);
 

From 1b30c0f4fbc9bad48d0689fd748206ce7072b38d Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 1 Jun 2014 15:57:12 +0100
Subject: [PATCH 44/53] Extract merge_overlapping as a free function template

---
 src/normal.cc    | 22 +++++++++-------------
 src/selection.cc |  4 ++--
 src/selection.hh | 48 ++++++++++++++++++++++++------------------------
 3 files changed, 35 insertions(+), 39 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index cc7eaa88..92e5727a 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1155,7 +1155,7 @@ void spaces_to_tabs(Context& context, int ts)
     }
 }
 
-static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, size_t timestamp)
+static std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
 {
     std::vector<Selection> ranges;
     for (auto& change : buffer.changes_since(timestamp))
@@ -1183,29 +1183,25 @@ static boost::optional<SelectionList> compute_modified_ranges(Buffer& buffer, si
             ranges.insert(it, Selection{pos, pos});
         }
     }
-    if (ranges.empty())
-        return {};
-
     for (auto& sel : ranges)
     {
         sel.anchor() = buffer.clamp(sel.anchor());
         sel.cursor() = buffer.clamp(sel.cursor());
     }
 
-    SelectionList result{buffer, std::move(ranges)};
-
     auto touches = [&](const Selection& lhs, const Selection& rhs) {
         return lhs.min() <= rhs.min() ? buffer.char_next(lhs.max()) >= rhs.min()
                                       : lhs.min() <= buffer.char_next(rhs.max());
     };
-    result.merge_overlapping(touches);
+    size_t main = 0;
+    merge_overlapping(ranges.begin(), ranges.end(), main, touches);
 
-    for (auto& sel : result)
+    for (auto& sel : ranges)
     {
         if (sel.anchor() != sel.cursor())
             sel.cursor() = buffer.char_prev(sel.cursor());
     }
-    return result;
+    return ranges;
 }
 
 void undo(Context& context, int)
@@ -1216,8 +1212,8 @@ void undo(Context& context, int)
     if (res)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
-        if (ranges)
-            context.selections() = std::move(*ranges);
+        if (not ranges.empty())
+            context.selections() = std::move(ranges);
     }
     else if (not res)
         context.print_status({ "nothing left to undo", get_color("Information") });
@@ -1232,8 +1228,8 @@ void redo(Context& context, int)
     if (res)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
-        if (ranges)
-            context.selections() = std::move(*ranges);
+        if (not ranges.empty())
+            context.selections() = std::move(ranges);
     }
 
     else if (not res)
diff --git a/src/selection.cc b/src/selection.cc
index b45c1898..c96baa37 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -166,7 +166,7 @@ void SelectionList::update()
         sel.anchor() = m_buffer->clamp(sel.anchor());
         sel.cursor() = m_buffer->clamp(sel.cursor());
     }
-    merge_overlapping(overlaps);
+    m_selections.erase(merge_overlapping(begin(), end(), m_main, overlaps), end());
     check_invariant();
 
     m_timestamp = m_buffer->timestamp();
@@ -208,7 +208,7 @@ void SelectionList::sort_and_merge_overlapping()
                                    return begin < main_begin;
                            });
     std::stable_sort(begin(), end(), compare_selections);
-    merge_overlapping(overlaps);
+    m_selections.erase(merge_overlapping(begin(), end(), m_main, overlaps), end());
 }
 namespace
 {
diff --git a/src/selection.hh b/src/selection.hh
index 652a558f..d9c2ea87 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -71,6 +71,30 @@ enum class InsertMode : unsigned
     OpenLineAbove
 };
 
+template<typename Iterator, typename OverlapsFunc>
+Iterator merge_overlapping(Iterator begin, Iterator end, size_t& main, OverlapsFunc overlaps)
+{
+    kak_assert(std::is_sorted(begin, end, compare_selections));
+    size_t size = end - begin;
+    size_t i = 0;
+    for (size_t j = 1; j < size; ++j)
+    {
+        if (overlaps(begin[i], begin[j]))
+        {
+            begin[i].merge_with(begin[j]);
+            if (i < main)
+                --main;
+        }
+        else
+        {
+            ++i;
+            if (i != j)
+                begin[i] = std::move(begin[j]);
+        }
+    }
+    return begin + i + 1;
+}
+
 struct SelectionList
 {
     SelectionList(Buffer& buffer, Selection s);
@@ -122,30 +146,6 @@ struct SelectionList
     bool operator==(const SelectionList& other) const { return m_buffer == other.m_buffer and m_selections == other.m_selections; }
     bool operator!=(const SelectionList& other) const { return !((*this) == other); }
 
-    template<typename OverlapsFunc>
-    void merge_overlapping(OverlapsFunc overlaps)
-    {
-        kak_assert(std::is_sorted(begin(), end(), compare_selections));
-        size_t i = 0;
-        for (size_t j = 1; j < size(); ++j)
-        {
-            if (overlaps((*this)[i], (*this)[j]))
-            {
-                (*this)[i].merge_with((*this)[j]);
-                if (i < m_main)
-                    --m_main;
-            }
-            else
-            {
-                ++i;
-                if (i != j)
-                    (*this)[i] = std::move((*this)[j]);
-            }
-        }
-        m_selections.erase(begin() + i + 1, end());
-        kak_assert(std::is_sorted(begin(), end(), compare_selections));
-    }
-
     void sort_and_merge_overlapping();
 
     Buffer& buffer() const { return *m_buffer; }

From a5e028e1b16f1fc802b8dcee26791e8c64ac2aea Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 1 Jun 2014 16:01:38 +0100
Subject: [PATCH 45/53] Add Context::set_selections(std::vector<Selection>)

This methods avoids updating the context selection needlessly as
they are going to get replaced anyway.
---
 src/context.cc | 5 +++++
 src/context.hh | 1 +
 src/normal.cc  | 8 ++++----
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/context.cc b/src/context.cc
index e909f1f5..21704168 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -202,6 +202,11 @@ std::vector<String> Context::selections_content() const
     return contents;
 }
 
+void Context::set_selections(std::vector<Selection> sels)
+{
+    *m_selections = std::move(sels);
+}
+
 void Context::begin_edition()
 {
     if (m_edition_level >= 0)
diff --git a/src/context.hh b/src/context.hh
index 90961216..3aa4e0cf 100644
--- a/src/context.hh
+++ b/src/context.hh
@@ -51,6 +51,7 @@ public:
     SelectionList& selections();
     const SelectionList& selections() const;
     std::vector<String>  selections_content() const;
+    void set_selections(std::vector<Selection> sels);
 
     void change_buffer(Buffer& buffer);
 
diff --git a/src/normal.cc b/src/normal.cc
index 92e5727a..5cc013df 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -725,7 +725,7 @@ void keep(Context& context, int)
         }
         if (keep.empty())
             throw runtime_error("no selections remaining");
-        context.selections() = std::move(keep);
+        context.set_selections(std::move(keep));
     });
 }
 
@@ -749,7 +749,7 @@ void keep_pipe(Context& context, int)
             }
             if (keep.empty())
                 throw runtime_error("no selections remaining");
-            context.selections() = std::move(keep);
+            context.set_selections(std::move(keep));
     });
 }
 template<bool indent_empty = false>
@@ -1213,7 +1213,7 @@ void undo(Context& context, int)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
         if (not ranges.empty())
-            context.selections() = std::move(ranges);
+            context.set_selections(std::move(ranges));
     }
     else if (not res)
         context.print_status({ "nothing left to undo", get_color("Information") });
@@ -1229,7 +1229,7 @@ void redo(Context& context, int)
     {
         auto ranges = compute_modified_ranges(buffer, timestamp);
         if (not ranges.empty())
-            context.selections() = std::move(ranges);
+            context.set_selections(std::move(ranges));
     }
 
     else if (not res)

From 23a1914d7e0bff8f71608b81348632c676e3ae19 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 2 Jun 2014 02:16:19 +0100
Subject: [PATCH 46/53] Optimize SelectionList::update in the case where
 changes are backward

This case arise on undo, reverse sorted changes that are not overlapping.
---
 src/selection.cc | 99 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 76 insertions(+), 23 deletions(-)

diff --git a/src/selection.cc b/src/selection.cc
index c96baa37..d4520f28 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -121,6 +121,67 @@ struct PositionChangesTracker
     }
 };
 
+bool relevant(const Buffer::Change& change, ByteCoord coord)
+{
+    return change.type == Buffer::Change::Insert ? change.begin <= coord
+                                                 : change.begin < coord;
+}
+
+void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections)
+{
+    PositionChangesTracker changes_tracker;
+
+    auto change_it = changes.begin();
+    auto advance_while_relevant = [&](const ByteCoord& pos) mutable {
+        while (relevant(*change_it, changes_tracker.get_new_coord(pos)) and
+               change_it != changes.end())
+            changes_tracker.update(*change_it++);
+    };
+
+    for (auto& sel : selections)
+    {
+        auto& sel_min = sel.min();
+        auto& sel_max = sel.max();
+        advance_while_relevant(sel_min);
+        sel_min = changes_tracker.get_new_coord(sel_min);
+
+        advance_while_relevant(sel_max);
+        sel_max = changes_tracker.get_new_coord(sel_max);
+    }
+}
+
+void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections)
+{
+    PositionChangesTracker changes_tracker;
+
+    using ReverseIt = std::reverse_iterator<const Buffer::Change*>;
+    auto change_it = ReverseIt(changes.end());
+    auto change_end = ReverseIt(changes.begin());
+    auto advance_while_relevant = [&](const ByteCoord& pos) mutable {
+        while (change_it != change_end)
+        {
+            auto change = *change_it;
+            change.begin = changes_tracker.get_new_coord(change.begin);
+            change.end = changes_tracker.get_new_coord(change.end);
+            if (not relevant(change, changes_tracker.get_new_coord(pos)))
+                break;
+            changes_tracker.update(change);
+            ++change_it;
+        }
+    };
+
+    for (auto& sel : selections)
+    {
+        auto& sel_min = sel.min();
+        auto& sel_max = sel.max();
+        advance_while_relevant(sel_min);
+        sel_min = changes_tracker.get_new_coord(sel_min);
+
+        advance_while_relevant(sel_max);
+        sel_max = changes_tracker.get_new_coord(sel_max);
+    }
+}
+
 }
 
 void SelectionList::update()
@@ -128,38 +189,30 @@ void SelectionList::update()
     if (m_timestamp == m_buffer->timestamp())
         return;
 
-    auto compare = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
+    auto forward = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
         { return lhs.begin < rhs.begin; };
-    auto relevant = [](const Buffer::Change& change, const ByteCoord& coord)
-        { return change.type == Buffer::Change::Insert ? change.begin <= coord
-                                                       : change.begin < coord; };
+    auto backward = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
+        { return lhs.begin > rhs.end; };
 
     auto changes = m_buffer->changes_since(m_timestamp);
     auto change_it = changes.begin();
     while (change_it != changes.end())
     {
-        auto change_end = std::is_sorted_until(change_it, changes.end(), compare);
-        PositionChangesTracker changes_tracker;
+        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward);
+        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward);
 
-        auto advance_while_relevant = [&](const ByteCoord& pos) mutable {
-            while (relevant(*change_it, pos) and change_it != change_end)
-                changes_tracker.update(*change_it++);
-            while (change_it != change_end and
-                   change_it->begin == changes_tracker.last_pos)
-                changes_tracker.update(*change_it++);
-        };
-
-        for (auto& sel : m_selections)
+        if (forward_end >= backward_end)
         {
-            auto& sel_min = sel.min();
-            auto& sel_max = sel.max();
-            advance_while_relevant(sel_min);
-            sel_min = changes_tracker.get_new_coord(sel_min);
-
-            advance_while_relevant(sel_max);
-            sel_max = changes_tracker.get_new_coord(sel_max);
+            update_forward({ change_it, forward_end }, m_selections);
+            change_it = forward_end;
         }
-        change_it = change_end;
+        else
+        {
+            update_backward({ change_it, backward_end }, m_selections);
+            change_it = backward_end;
+        }
+        kak_assert(std::is_sorted(m_selections.begin(), m_selections.end(),
+                                  compare_selections));
     }
     for (auto& sel : m_selections)
     {

From d33c27acdf7ebf5c9be0ab1406ae4c7e66fb671e Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 2 Jun 2014 15:13:56 +0100
Subject: [PATCH 47/53] Move compute_modified_ranges to selection.cc and use an
 optimized approach

---
 src/normal.cc    |  49 -----------------
 src/selection.cc | 137 ++++++++++++++++++++++++++++++++++++-----------
 src/selection.hh |  32 +----------
 3 files changed, 107 insertions(+), 111 deletions(-)

diff --git a/src/normal.cc b/src/normal.cc
index 5cc013df..1a046b6d 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1155,55 +1155,6 @@ void spaces_to_tabs(Context& context, int ts)
     }
 }
 
-static std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
-{
-    std::vector<Selection> ranges;
-    for (auto& change : buffer.changes_since(timestamp))
-    {
-        const ByteCoord& begin = change.begin;
-        const ByteCoord& end = change.end;
-        if (change.type == Buffer::Change::Insert)
-        {
-            update_insert(ranges, begin, end);
-            auto it = std::upper_bound(ranges.begin(), ranges.end(), begin,
-                                       [](ByteCoord c, const Selection& sel)
-                                       { return c < sel.min(); });
-            ranges.insert(it, Selection{begin, end});
-        }
-        else
-        {
-            update_erase(ranges, begin, end);
-            auto pos = begin;
-            if (change.at_end)
-                pos = begin.column ? ByteCoord{begin.line, begin.column - 1}
-                                   : ByteCoord{begin.line - 1};
-            auto it = std::upper_bound(ranges.begin(), ranges.end(), pos,
-                                       [](ByteCoord c, const Selection& sel)
-                                       { return c < sel.min(); });
-            ranges.insert(it, Selection{pos, pos});
-        }
-    }
-    for (auto& sel : ranges)
-    {
-        sel.anchor() = buffer.clamp(sel.anchor());
-        sel.cursor() = buffer.clamp(sel.cursor());
-    }
-
-    auto touches = [&](const Selection& lhs, const Selection& rhs) {
-        return lhs.min() <= rhs.min() ? buffer.char_next(lhs.max()) >= rhs.min()
-                                      : lhs.min() <= buffer.char_next(rhs.max());
-    };
-    size_t main = 0;
-    merge_overlapping(ranges.begin(), ranges.end(), main, touches);
-
-    for (auto& sel : ranges)
-    {
-        if (sel.anchor() != sel.cursor())
-            sel.cursor() = buffer.char_prev(sel.cursor());
-    }
-    return ranges;
-}
-
 void undo(Context& context, int)
 {
     Buffer& buffer = context.buffer();
diff --git a/src/selection.cc b/src/selection.cc
index d4520f28..586e886b 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -63,12 +63,33 @@ ByteCoord update_erase(ByteCoord coord, ByteCoord begin, ByteCoord end)
     return coord;
 }
 
-ByteCoord update_pos(ByteCoord coord, const Buffer::Change& change)
+static bool compare_selections(const Selection& lhs, const Selection& rhs)
 {
-    if (change.type == Buffer::Change::Insert)
-        return update_insert(coord, change.begin, change.end);
-    else
-        return update_erase(coord, change.begin, change.end);
+    return lhs.min() < rhs.min();
+}
+
+template<typename Iterator, typename OverlapsFunc>
+Iterator merge_overlapping(Iterator begin, Iterator end, size_t& main, OverlapsFunc overlaps)
+{
+    kak_assert(std::is_sorted(begin, end, compare_selections));
+    size_t size = end - begin;
+    size_t i = 0;
+    for (size_t j = 1; j < size; ++j)
+    {
+        if (overlaps(begin[i], begin[j]))
+        {
+            begin[i].merge_with(begin[j]);
+            if (i < main)
+                --main;
+        }
+        else
+        {
+            ++i;
+            if (i != j)
+                begin[i] = std::move(begin[j]);
+        }
+    }
+    return begin + i + 1;
 }
 
 // This tracks position changes for changes that are done
@@ -109,7 +130,7 @@ struct PositionChangesTracker
     ByteCoord get_new_coord(ByteCoord coord)
     {
         if (last_pos.line - pos_change.line == coord.line)
-            coord.column += pos_change.column;
+            coord.column = std::max(0_byte, coord.column + pos_change.column);
         coord.line += pos_change.line;
         return coord;
     }
@@ -127,6 +148,16 @@ bool relevant(const Buffer::Change& change, ByteCoord coord)
                                                  : change.begin < coord;
 }
 
+bool forward_sorted(const Buffer::Change& lhs, const Buffer::Change& rhs)
+{
+    return lhs.begin < rhs.begin;
+}
+
+bool backward_sorted(const Buffer::Change& lhs, const Buffer::Change& rhs)
+{
+    return lhs.begin > rhs.end;
+}
+
 void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections)
 {
     PositionChangesTracker changes_tracker;
@@ -184,22 +215,84 @@ void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>&
 
 }
 
+std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
+{
+    std::vector<Selection> ranges;
+    auto changes = buffer.changes_since(timestamp);
+    auto change_it = changes.begin();
+    while (change_it != changes.end())
+    {
+        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward_sorted);
+        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward_sorted);
+
+        size_t prev_size = ranges.size();
+        if (forward_end >= backward_end)
+        {
+            update_forward({ change_it, forward_end }, ranges);
+
+            PositionChangesTracker changes_tracker;
+            for (; change_it != forward_end; ++change_it)
+            {
+                if (change_it->type == Buffer::Change::Insert)
+                    ranges.push_back({ change_it->begin, change_it->end });
+                else
+                    ranges.push_back({ change_it->begin });
+                changes_tracker.update(*change_it);
+            }
+        }
+        else
+        {
+            update_backward({ change_it, backward_end }, ranges);
+
+            using ReverseIt = std::reverse_iterator<const Buffer::Change*>;
+            PositionChangesTracker changes_tracker;
+            for (ReverseIt it{backward_end}, end{change_it}; it != end; ++it)
+            {
+                if (it->type == Buffer::Change::Insert)
+                    ranges.push_back({ changes_tracker.get_new_coord(it->begin),
+                                       changes_tracker.get_new_coord(it->end) });
+                else
+                    ranges.push_back({ changes_tracker.get_new_coord(it->begin) });
+                changes_tracker.update(*it);
+            }
+            change_it = backward_end;
+        }
+
+        kak_assert(std::is_sorted(ranges.begin(), ranges.begin() + prev_size, compare_selections));
+        kak_assert(std::is_sorted(ranges.begin() + prev_size, ranges.end(), compare_selections));
+        std::inplace_merge(ranges.begin(), ranges.begin() + prev_size, ranges.end(), compare_selections);
+    }
+    for (auto& sel : ranges)
+    {
+        sel.anchor() = buffer.clamp(sel.anchor());
+        sel.cursor() = buffer.clamp(sel.cursor());
+    }
+
+    auto touches = [&](const Selection& lhs, const Selection& rhs) {
+        return buffer.char_next(lhs.max()) >= rhs.min();
+    };
+    size_t dummy = 0;
+    ranges.erase(merge_overlapping(ranges.begin(), ranges.end(), dummy, touches), ranges.end());
+
+    for (auto& sel : ranges)
+    {
+        if (sel.anchor() != sel.cursor())
+            sel.cursor() = buffer.char_prev(sel.cursor());
+    }
+    return ranges;
+}
+
 void SelectionList::update()
 {
     if (m_timestamp == m_buffer->timestamp())
         return;
 
-    auto forward = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
-        { return lhs.begin < rhs.begin; };
-    auto backward = [](const Buffer::Change& lhs, const Buffer::Change& rhs)
-        { return lhs.begin > rhs.end; };
-
     auto changes = m_buffer->changes_since(m_timestamp);
     auto change_it = changes.begin();
     while (change_it != changes.end())
     {
-        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward);
-        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward);
+        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward_sorted);
+        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward_sorted);
 
         if (forward_end >= backward_end)
         {
@@ -375,22 +468,4 @@ void SelectionList::erase()
     m_buffer->check_invariant();
 }
 
-void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end)
-{
-    for (auto& sel : sels)
-    {
-        sel.anchor() = update_insert(sel.anchor(), begin, end);
-        sel.cursor() = update_insert(sel.cursor(), begin, end);
-    }
-}
-
-void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end)
-{
-    for (auto& sel : sels)
-    {
-        sel.anchor() = update_erase(sel.anchor(), begin, end);
-        sel.cursor() = update_erase(sel.cursor(), begin, end);
-    }
-}
-
 }
diff --git a/src/selection.hh b/src/selection.hh
index d9c2ea87..cdfca6b6 100644
--- a/src/selection.hh
+++ b/src/selection.hh
@@ -53,11 +53,6 @@ inline bool overlaps(const Selection& lhs, const Selection& rhs)
                                   : lhs.min() <= rhs.max();
 }
 
-static bool compare_selections(const Selection& lhs, const Selection& rhs)
-{
-    return lhs.min() < rhs.min();
-}
-
 enum class InsertMode : unsigned
 {
     Insert,
@@ -71,30 +66,6 @@ enum class InsertMode : unsigned
     OpenLineAbove
 };
 
-template<typename Iterator, typename OverlapsFunc>
-Iterator merge_overlapping(Iterator begin, Iterator end, size_t& main, OverlapsFunc overlaps)
-{
-    kak_assert(std::is_sorted(begin, end, compare_selections));
-    size_t size = end - begin;
-    size_t i = 0;
-    for (size_t j = 1; j < size; ++j)
-    {
-        if (overlaps(begin[i], begin[j]))
-        {
-            begin[i].merge_with(begin[j]);
-            if (i < main)
-                --main;
-        }
-        else
-        {
-            ++i;
-            if (i != j)
-                begin[i] = std::move(begin[j]);
-        }
-    }
-    return begin + i + 1;
-}
-
 struct SelectionList
 {
     SelectionList(Buffer& buffer, Selection s);
@@ -164,8 +135,7 @@ private:
     size_t m_timestamp;
 };
 
-void update_insert(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end);
-void update_erase(std::vector<Selection>& sels, ByteCoord begin, ByteCoord end);
+std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp);
 
 }
 

From c8354588c9af6a9d5064ec4e9665b1eea6c4eb77 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 2 Jun 2014 15:17:56 +0100
Subject: [PATCH 48/53] Remove undo group optimizer

---
 src/buffer.cc | 188 --------------------------------------------------
 1 file changed, 188 deletions(-)

diff --git a/src/buffer.cc b/src/buffer.cc
index 91f143c8..884ae270 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -181,200 +181,12 @@ struct Buffer::Modification
     }
 };
 
-class UndoGroupOptimizer
-{
-    static constexpr auto Insert = Buffer::Modification::Type::Insert;
-    static constexpr auto Erase = Buffer::Modification::Type::Erase;
-
-    static ByteCoord advance(ByteCoord coord, const String& str)
-    {
-        for (auto c : str)
-        {
-            if (c == '\n')
-            {
-                ++coord.line;
-                coord.column = 0;
-            }
-            else
-                ++coord.column;
-        }
-        return coord;
-    }
-
-    static ByteCount count_byte_to(ByteCoord pos, ByteCoord endpos, const String& str)
-    {
-        ByteCount count = 0;
-        for (auto it = str.begin(); it != str.end() and pos != endpos; ++it)
-        {
-            if (*it == '\n')
-            {
-                ++pos.line;
-                pos.column = 0;
-            }
-            else
-                ++pos.column;
-            ++count;
-        }
-        kak_assert(pos == endpos);
-        return count;
-    }
-
-    static const ByteCount overlaps(const String& lhs, const String& rhs)
-    {
-        if (lhs.empty() or rhs.empty())
-            return -1;
-
-        char c = rhs.front();
-        ByteCount pos = 0;
-        while ((pos = (int)lhs.find_first_of(c, (int)pos)) != -1)
-        {
-            ByteCount i = pos, j = 0;
-            while (i != lhs.length() and j != rhs.length() and lhs[i] == rhs[j])
-                 ++i, ++j;
-            if (i == lhs.length())
-                break;
-            ++pos;
-        }
-        return pos;
-    }
-
-    static bool merge_contiguous(Buffer::UndoGroup& undo_group)
-    {
-        bool progress = false;
-        auto it = undo_group.begin();
-        auto it_next = it+1;
-        while (it_next != undo_group.end())
-        {
-            ByteCount pos;
-            auto& coord = it->coord;
-            auto& next_coord = it_next->coord;
-
-            // reorders modification doing a kind of custom bubble sort
-            // so we have a O(n²) worst case complexity of the undo group optimization
-            if (next_coord < coord)
-            {
-                ByteCoord next_end = advance(next_coord, it_next->content);
-                if (it_next->type == Insert)
-                {
-                    if (coord.line == next_coord.line)
-                        coord.column += next_end.column - next_coord.column;
-                    coord.line += next_end.line - next_coord.line;
-                }
-                else if (it->type == Insert and next_end > coord)
-                {
-                    ByteCount start = count_byte_to(next_coord, coord, it_next->content);
-                    ByteCount len = std::min(it->content.length(), it_next->content.length() - start);
-                    kak_assert(it_next->content.substr(start, len) == it->content.substr(0, len));
-                    it->coord = it_next->coord;
-                    it->content = it->content.substr(len);
-                    it_next->content = it_next->content.substr(0,start) + it_next->content.substr(start + len);
-                }
-                else if (it->type == Erase and next_end >= coord)
-                {
-                    ByteCount start = count_byte_to(next_coord, coord, it_next->content);
-                    it_next->content = it_next->content.substr(0, start) + it->content + it_next->content.substr(start);
-                    it->coord = it_next->coord;
-                    it->content.clear();
-                }
-                else
-                {
-                    if (next_end.line == coord.line)
-                    {
-                        coord.line = next_coord.line;
-                        coord.column = next_coord.column + coord.column - next_end.column;
-                    }
-                    else
-                        coord.line -= next_end.line - next_coord.line;
-                }
-                std::swap(*it, *it_next);
-                progress = true;
-            }
-
-            kak_assert(coord <= next_coord);
-            if (it->type == Erase and it_next->type == Erase and coord == next_coord)
-            {
-                it->content += it_next->content;
-                it_next = undo_group.erase(it_next);
-                progress = true;
-            }
-            else if (it->type == Insert and it_next->type == Insert and
-                     is_in_range(next_coord, coord, advance(coord, it->content)))
-            {
-                ByteCount prefix_len = count_byte_to(coord, next_coord, it->content);
-                it->content = it->content.substr(0, prefix_len) + it_next->content
-                            + it->content.substr(prefix_len);
-                it_next = undo_group.erase(it_next);
-                progress = true;
-            }
-            else if (it->type == Insert and it_next->type == Erase and
-                     next_coord < advance(coord, it->content))
-            {
-                ByteCount insert_len = it->content.length();
-                ByteCount erase_len  = it_next->content.length();
-                ByteCount prefix_len = count_byte_to(coord, next_coord, it->content);
-
-                ByteCount suffix_len = insert_len - prefix_len;
-                if (suffix_len >= erase_len)
-                {
-                    it->content = it->content.substr(0, prefix_len) + it->content.substr(prefix_len + erase_len);
-                    it_next = undo_group.erase(it_next);
-                }
-                else
-                {
-                    it->content = it->content.substr(0, prefix_len);
-                    it_next->content = it_next->content.substr(suffix_len);
-                    ++it, ++it_next;
-                }
-                progress = true;
-            }
-            else if (it->type == Erase and it_next->type == Insert and coord == next_coord and
-                     (pos = overlaps(it->content, it_next->content)) != -1)
-            {
-                ByteCount overlaps_len = it->content.length() - pos;
-                it->content = it->content.substr(0, pos);
-                it_next->coord = advance(it_next->coord, it_next->content.substr(0, overlaps_len));
-                it_next->content = it_next->content.substr(overlaps_len);
-                ++it, ++it_next;
-                progress = true;
-            }
-            else
-                ++it, ++it_next;
-        }
-        return progress;
-    }
-
-    static bool erase_empty(Buffer::UndoGroup& undo_group)
-    {
-        auto it = std::remove_if(begin(undo_group), end(undo_group),
-                                 [](Buffer::Modification& m) { return m.content.empty(); });
-        if (it != end(undo_group))
-        {
-            undo_group.erase(it, end(undo_group));
-            return true;
-        }
-        return false;
-    }
-public:
-    static void optimize(Buffer::UndoGroup& undo_group)
-    {
-        while (undo_group.size() > 1)
-        {
-            bool progress = false;
-            progress |= merge_contiguous(undo_group);
-            progress |= erase_empty(undo_group);
-            if (not progress)
-                break;
-        }
-    }
-};
 
 void Buffer::commit_undo_group()
 {
     if (m_flags & Flags::NoUndo)
         return;
 
-    UndoGroupOptimizer::optimize(m_current_undo_group);
-
     if (m_current_undo_group.empty())
         return;
 

From 8d9ed5e8c7948025eee43a0a0ad30f4cc06b1912 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 2 Jun 2014 15:42:03 +0100
Subject: [PATCH 49/53] Fix in region highlighter

---
 src/highlighters.cc | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/highlighters.cc b/src/highlighters.cc
index a51f764e..ab765bb2 100644
--- a/src/highlighters.cc
+++ b/src/highlighters.cc
@@ -772,15 +772,14 @@ private:
             auto modif_it = std::lower_bound(modifs.begin(), modifs.end(), it->line,
                                              [](const LineModification& c, const LineCount& l)
                                              { return c.old_line < l; });
-            bool erase = false;
-            if (modif_it != modifs.begin())
+
+            bool erase = (modif_it != modifs.end() and modif_it->old_line == it->line);
+            if (not erase and modif_it != modifs.begin())
             {
                 auto& prev = *(modif_it-1);
                 erase = it->line <= prev.old_line + prev.num_removed;
                 it->line += prev.diff();
             }
-            if (modif_it != modifs.end() and modif_it->old_line == it->line)
-                erase = true;
             erase = erase or (it->line >= buffer.line_count());
 
             if (not erase)

From f7e89bc9f817ff4c34d6ca5debf53c5a3a3ca924 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 2 Jun 2014 17:36:46 +0100
Subject: [PATCH 50/53] Fix selection updating, avoid overlapping selections

---
 src/selection.cc | 53 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 37 insertions(+), 16 deletions(-)

diff --git a/src/selection.cc b/src/selection.cc
index 586e886b..f5e87e46 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -71,6 +71,9 @@ static bool compare_selections(const Selection& lhs, const Selection& rhs)
 template<typename Iterator, typename OverlapsFunc>
 Iterator merge_overlapping(Iterator begin, Iterator end, size_t& main, OverlapsFunc overlaps)
 {
+    if (begin == end)
+        return begin;
+
     kak_assert(std::is_sorted(begin, end, compare_selections));
     size_t size = end - begin;
     size_t i = 0;
@@ -148,17 +151,27 @@ bool relevant(const Buffer::Change& change, ByteCoord coord)
                                                  : change.begin < coord;
 }
 
-bool forward_sorted(const Buffer::Change& lhs, const Buffer::Change& rhs)
+const Buffer::Change* forward_sorted_until(const Buffer::Change* first, const Buffer::Change* last)
 {
-    return lhs.begin < rhs.begin;
+    return std::is_sorted_until(first, last,
+                                [](const Buffer::Change& lhs, const Buffer::Change& rhs)
+                                { return lhs.begin < rhs.begin; });
 }
 
-bool backward_sorted(const Buffer::Change& lhs, const Buffer::Change& rhs)
+const Buffer::Change* backward_sorted_until(const Buffer::Change* first, const Buffer::Change* last)
 {
-    return lhs.begin > rhs.end;
+    if (first != last) {
+        const Buffer::Change* next = first;
+        while (++next != last) {
+            if (next->end >= first->begin)
+                return next;
+            first = next;
+        }
+    }
+    return last;
 }
 
-void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections)
+void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections, size_t& main)
 {
     PositionChangesTracker changes_tracker;
 
@@ -179,9 +192,12 @@ void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>&
         advance_while_relevant(sel_max);
         sel_max = changes_tracker.get_new_coord(sel_max);
     }
+    selections.erase(merge_overlapping(selections.begin(), selections.end(), main, overlaps),
+                     selections.end());
+    kak_assert(std::is_sorted(selections.begin(), selections.end(), compare_selections));
 }
 
-void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections)
+void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections, size_t& main)
 {
     PositionChangesTracker changes_tracker;
 
@@ -211,6 +227,9 @@ void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>&
         advance_while_relevant(sel_max);
         sel_max = changes_tracker.get_new_coord(sel_max);
     }
+    selections.erase(merge_overlapping(selections.begin(), selections.end(), main, overlaps),
+                     selections.end());
+    kak_assert(std::is_sorted(selections.begin(), selections.end(), compare_selections));
 }
 
 }
@@ -222,13 +241,15 @@ std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
     auto change_it = changes.begin();
     while (change_it != changes.end())
     {
-        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward_sorted);
-        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward_sorted);
+        auto forward_end = forward_sorted_until(change_it, changes.end());
+        auto backward_end = backward_sorted_until(change_it, changes.end());
 
-        size_t prev_size = ranges.size();
+        size_t prev_size;
+        size_t dummy = 0;
         if (forward_end >= backward_end)
         {
-            update_forward({ change_it, forward_end }, ranges);
+            update_forward({ change_it, forward_end }, ranges, dummy);
+            prev_size = ranges.size();
 
             PositionChangesTracker changes_tracker;
             for (; change_it != forward_end; ++change_it)
@@ -242,7 +263,8 @@ std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
         }
         else
         {
-            update_backward({ change_it, backward_end }, ranges);
+            update_backward({ change_it, backward_end }, ranges, dummy);
+            prev_size = ranges.size();
 
             using ReverseIt = std::reverse_iterator<const Buffer::Change*>;
             PositionChangesTracker changes_tracker;
@@ -258,7 +280,6 @@ std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
             change_it = backward_end;
         }
 
-        kak_assert(std::is_sorted(ranges.begin(), ranges.begin() + prev_size, compare_selections));
         kak_assert(std::is_sorted(ranges.begin() + prev_size, ranges.end(), compare_selections));
         std::inplace_merge(ranges.begin(), ranges.begin() + prev_size, ranges.end(), compare_selections);
     }
@@ -291,17 +312,17 @@ void SelectionList::update()
     auto change_it = changes.begin();
     while (change_it != changes.end())
     {
-        auto forward_end = std::is_sorted_until(change_it, changes.end(), forward_sorted);
-        auto backward_end = std::is_sorted_until(change_it, changes.end(), backward_sorted);
+        auto forward_end = forward_sorted_until(change_it, changes.end());
+        auto backward_end = backward_sorted_until(change_it, changes.end());
 
         if (forward_end >= backward_end)
         {
-            update_forward({ change_it, forward_end }, m_selections);
+            update_forward({ change_it, forward_end }, m_selections, m_main);
             change_it = forward_end;
         }
         else
         {
-            update_backward({ change_it, backward_end }, m_selections);
+            update_backward({ change_it, backward_end }, m_selections, m_main);
             change_it = backward_end;
         }
         kak_assert(std::is_sorted(m_selections.begin(), m_selections.end(),

From 26f69b199eec9e9609500d059e647a2dbbacd218 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Wed, 4 Jun 2014 23:23:37 +0100
Subject: [PATCH 51/53] Rework and fix corner cases in selection updating code

---
 src/context.cc   |   1 +
 src/selection.cc | 133 +++++++++++++++++++++++++++++------------------
 2 files changed, 84 insertions(+), 50 deletions(-)

diff --git a/src/context.cc b/src/context.cc
index 21704168..4f28b596 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -205,6 +205,7 @@ std::vector<String> Context::selections_content() const
 void Context::set_selections(std::vector<Selection> sels)
 {
     *m_selections = std::move(sels);
+    (*m_selections).check_invariant();
 }
 
 void Context::begin_edition()
diff --git a/src/selection.cc b/src/selection.cc
index f5e87e46..22f40f25 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -98,28 +98,24 @@ Iterator merge_overlapping(Iterator begin, Iterator end, size_t& main, OverlapsF
 // This tracks position changes for changes that are done
 // in a forward way (each change takes place at a position)
 // *after* the previous one.
-struct PositionChangesTracker
+struct ForwardChangesTracker
 {
-    ByteCoord last_pos;
-    ByteCoord pos_change;
+    ByteCoord cur_pos; // last change position at current modification
+    ByteCoord old_pos; // last change position at start
 
     void update(const Buffer::Change& change)
     {
+        kak_assert(change.begin >= cur_pos);
+
         if (change.type == Buffer::Change::Insert)
         {
-            pos_change.line += change.end.line - change.begin.line;
-            if (change.begin.line != last_pos.line)
-                pos_change.column = 0;
-            pos_change.column += change.end.column - change.begin.column;
-            last_pos = change.end;
+            old_pos = get_old_coord(change.begin);
+            cur_pos = change.end;
         }
         else if (change.type == Buffer::Change::Erase)
         {
-            pos_change.line -= change.end.line - change.begin.line;
-            if (last_pos.line != change.end.line)
-                pos_change.column = 0;
-            pos_change.column -= change.end.column - change.begin.column;
-            last_pos = change.begin;
+            old_pos = get_old_coord(change.end);
+            cur_pos = change.begin;
         }
     }
 
@@ -130,32 +126,61 @@ struct PositionChangesTracker
         timestamp = buffer.timestamp();
     }
 
-    ByteCoord get_new_coord(ByteCoord coord)
+    ByteCoord get_old_coord(ByteCoord coord) const
     {
-        if (last_pos.line - pos_change.line == coord.line)
-            coord.column = std::max(0_byte, coord.column + pos_change.column);
-        coord.line += pos_change.line;
+        kak_assert(cur_pos <= coord);
+        auto pos_change = cur_pos - old_pos;
+        if (cur_pos.line == coord.line)
+        {
+            kak_assert(pos_change.column <= coord.column);
+            coord.column -= pos_change.column;
+        }
+        coord.line -= pos_change.line;
+        kak_assert(old_pos <= coord);
         return coord;
     }
 
-    void update_sel(Selection& sel)
+    ByteCoord get_new_coord(ByteCoord coord) const
     {
-        sel.anchor() = get_new_coord(sel.anchor());
-        sel.cursor() = get_new_coord(sel.cursor());
+        kak_assert(old_pos <= coord);
+        auto pos_change = cur_pos - old_pos;
+        if (old_pos.line == coord.line)
+        {
+            kak_assert(-pos_change.column <= coord.column);
+            coord.column += pos_change.column;
+        }
+        coord.line += pos_change.line;
+        kak_assert(cur_pos <= coord);
+        return coord;
+    }
+
+    ByteCoord get_new_coord_tolerant(ByteCoord coord) const
+    {
+        if (coord < old_pos)
+            return cur_pos;
+        return get_new_coord(coord);
+    }
+
+    bool relevant(const Buffer::Change& change, ByteCoord old_coord) const
+    {
+        auto new_coord = get_new_coord(old_coord);
+        return change.type == Buffer::Change::Insert ? change.begin <= new_coord
+                                                     : change.begin < new_coord;
     }
 };
 
-bool relevant(const Buffer::Change& change, ByteCoord coord)
-{
-    return change.type == Buffer::Change::Insert ? change.begin <= coord
-                                                 : change.begin < coord;
-}
-
 const Buffer::Change* forward_sorted_until(const Buffer::Change* first, const Buffer::Change* last)
 {
-    return std::is_sorted_until(first, last,
-                                [](const Buffer::Change& lhs, const Buffer::Change& rhs)
-                                { return lhs.begin < rhs.begin; });
+    if (first != last) {
+        const Buffer::Change* next = first;
+        while (++next != last) {
+            const auto& ref = first->type == Buffer::Change::Insert ? first->end : first->begin;
+            if (next->begin <= ref)
+                return next;
+            first = next;
+        }
+    }
+    return last;
 }
 
 const Buffer::Change* backward_sorted_until(const Buffer::Change* first, const Buffer::Change* last)
@@ -163,7 +188,7 @@ const Buffer::Change* backward_sorted_until(const Buffer::Change* first, const B
     if (first != last) {
         const Buffer::Change* next = first;
         while (++next != last) {
-            if (next->end >= first->begin)
+            if (first->begin <= next->end)
                 return next;
             first = next;
         }
@@ -173,12 +198,11 @@ const Buffer::Change* backward_sorted_until(const Buffer::Change* first, const B
 
 void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections, size_t& main)
 {
-    PositionChangesTracker changes_tracker;
+    ForwardChangesTracker changes_tracker;
 
     auto change_it = changes.begin();
     auto advance_while_relevant = [&](const ByteCoord& pos) mutable {
-        while (relevant(*change_it, changes_tracker.get_new_coord(pos)) and
-               change_it != changes.end())
+        while (change_it != changes.end() and changes_tracker.relevant(*change_it, pos))
             changes_tracker.update(*change_it++);
     };
 
@@ -187,10 +211,10 @@ void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>&
         auto& sel_min = sel.min();
         auto& sel_max = sel.max();
         advance_while_relevant(sel_min);
-        sel_min = changes_tracker.get_new_coord(sel_min);
+        sel_min = changes_tracker.get_new_coord_tolerant(sel_min);
 
         advance_while_relevant(sel_max);
-        sel_max = changes_tracker.get_new_coord(sel_max);
+        sel_max = changes_tracker.get_new_coord_tolerant(sel_max);
     }
     selections.erase(merge_overlapping(selections.begin(), selections.end(), main, overlaps),
                      selections.end());
@@ -199,7 +223,7 @@ void update_forward(memoryview<Buffer::Change> changes, std::vector<Selection>&
 
 void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>& selections, size_t& main)
 {
-    PositionChangesTracker changes_tracker;
+    ForwardChangesTracker changes_tracker;
 
     using ReverseIt = std::reverse_iterator<const Buffer::Change*>;
     auto change_it = ReverseIt(changes.end());
@@ -210,7 +234,7 @@ void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>&
             auto change = *change_it;
             change.begin = changes_tracker.get_new_coord(change.begin);
             change.end = changes_tracker.get_new_coord(change.end);
-            if (not relevant(change, changes_tracker.get_new_coord(pos)))
+            if (not changes_tracker.relevant(change, pos))
                 break;
             changes_tracker.update(change);
             ++change_it;
@@ -222,10 +246,10 @@ void update_backward(memoryview<Buffer::Change> changes, std::vector<Selection>&
         auto& sel_min = sel.min();
         auto& sel_max = sel.max();
         advance_while_relevant(sel_min);
-        sel_min = changes_tracker.get_new_coord(sel_min);
+        sel_min = changes_tracker.get_new_coord_tolerant(sel_min);
 
         advance_while_relevant(sel_max);
-        sel_max = changes_tracker.get_new_coord(sel_max);
+        sel_max = changes_tracker.get_new_coord_tolerant(sel_max);
     }
     selections.erase(merge_overlapping(selections.begin(), selections.end(), main, overlaps),
                      selections.end());
@@ -251,7 +275,7 @@ std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
             update_forward({ change_it, forward_end }, ranges, dummy);
             prev_size = ranges.size();
 
-            PositionChangesTracker changes_tracker;
+            ForwardChangesTracker changes_tracker;
             for (; change_it != forward_end; ++change_it)
             {
                 if (change_it->type == Buffer::Change::Insert)
@@ -267,21 +291,25 @@ std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp)
             prev_size = ranges.size();
 
             using ReverseIt = std::reverse_iterator<const Buffer::Change*>;
-            PositionChangesTracker changes_tracker;
+            ForwardChangesTracker changes_tracker;
             for (ReverseIt it{backward_end}, end{change_it}; it != end; ++it)
             {
-                if (it->type == Buffer::Change::Insert)
-                    ranges.push_back({ changes_tracker.get_new_coord(it->begin),
-                                       changes_tracker.get_new_coord(it->end) });
+                auto change = *it;
+                change.begin = changes_tracker.get_new_coord(change.begin);
+                change.end = changes_tracker.get_new_coord(change.end);
+
+                if (change.type == Buffer::Change::Insert)
+                    ranges.push_back({ change.begin, change.end });
                 else
-                    ranges.push_back({ changes_tracker.get_new_coord(it->begin) });
-                changes_tracker.update(*it);
+                    ranges.push_back({ change.begin });
+                changes_tracker.update(change);
             }
             change_it = backward_end;
         }
 
         kak_assert(std::is_sorted(ranges.begin() + prev_size, ranges.end(), compare_selections));
         std::inplace_merge(ranges.begin(), ranges.begin() + prev_size, ranges.end(), compare_selections);
+        ranges.erase(merge_overlapping(ranges.begin(), ranges.end(), dummy, overlaps), ranges.end());
     }
     for (auto& sel : ranges)
     {
@@ -441,13 +469,14 @@ void SelectionList::insert(memoryview<String> strings, InsertMode mode)
         return;
 
     update();
-    PositionChangesTracker changes_tracker;
+    ForwardChangesTracker changes_tracker;
     for (size_t index = 0; index < m_selections.size(); ++index)
     {
         auto& sel = m_selections[index];
 
-        changes_tracker.update_sel(sel);
+        sel.anchor() = changes_tracker.get_new_coord(sel.anchor());
         kak_assert(m_buffer->is_valid(sel.anchor()));
+        sel.cursor() = changes_tracker.get_new_coord(sel.cursor());
         kak_assert(m_buffer->is_valid(sel.cursor()));
 
         auto pos = prepare_insert(*m_buffer, sel, mode);
@@ -478,10 +507,14 @@ void SelectionList::insert(memoryview<String> strings, InsertMode mode)
 void SelectionList::erase()
 {
     update();
-    PositionChangesTracker changes_tracker;
+    ForwardChangesTracker changes_tracker;
     for (auto& sel : m_selections)
     {
-        changes_tracker.update_sel(sel);
+        sel.anchor() = changes_tracker.get_new_coord(sel.anchor());
+        kak_assert(m_buffer->is_valid(sel.anchor()));
+        sel.cursor() = changes_tracker.get_new_coord(sel.cursor());
+        kak_assert(m_buffer->is_valid(sel.cursor()));
+
         auto pos = Kakoune::erase(*m_buffer, sel);
         sel.anchor() = sel.cursor() = m_buffer->clamp(pos.coord());
         changes_tracker.update(*m_buffer, m_timestamp);

From c28a61187b18df5a7835ae99aba30c42b70a5471 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Thu, 5 Jun 2014 19:41:31 +0100
Subject: [PATCH 52/53] Fix handling of empty insert

---
 src/selection.cc | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/selection.cc b/src/selection.cc
index 22f40f25..95b4e344 100644
--- a/src/selection.cc
+++ b/src/selection.cc
@@ -483,6 +483,13 @@ void SelectionList::insert(memoryview<String> strings, InsertMode mode)
         changes_tracker.update(*m_buffer, m_timestamp);
 
         const String& str = strings[std::min(index, strings.size()-1)];
+        if (str.empty())
+        {
+            if (mode == InsertMode::Replace)
+                sel.anchor() = sel.cursor() = pos.coord();
+            continue;
+        }
+
         pos = m_buffer->insert(pos, str);
 
         auto& change = m_buffer->changes_since(m_timestamp).back();

From 5245f0073c8712d26923da1b9925f90f6047290f Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Mon, 9 Jun 2014 23:23:49 +0100
Subject: [PATCH 53/53] Refactor InputMode::Insert::prepare

---
 src/input_handler.cc | 52 +++++++++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/src/input_handler.cc b/src/input_handler.cc
index bfbe12a7..d96a8f10 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -801,49 +801,47 @@ private:
                     cursor = buffer.char_next(cursor);
             }
             break;
-
-        case InsertMode::OpenLineBelow:
         case InsertMode::AppendAtLineEnd:
             for (auto& sel : selections)
                 sel = ByteCoord{sel.max().line, buffer[sel.max().line].length() - 1};
             break;
-
+        case InsertMode::OpenLineBelow:
+            for (auto& sel : selections)
+                sel = ByteCoord{sel.max().line, buffer[sel.max().line].length() - 1};
+            insert('\n');
+            break;
         case InsertMode::OpenLineAbove:
+            for (auto& sel : selections)
+            {
+                auto line = sel.min().line;
+                sel = line > 0 ? ByteCoord{line - 1, buffer[line-1].length() - 1}
+                               : ByteCoord{0, 0};
+            }
+            insert('\n');
+            // fix case where we inserted at begining
+            for (auto& sel : selections)
+            {
+                if (sel.anchor() == buffer.char_next({0,0}))
+                    sel = Selection{{0,0}};
+            }
+            break;
         case InsertMode::InsertAtLineBegin:
             for (auto& sel : selections)
             {
                 ByteCoord pos = sel.min().line;
-                if (mode == InsertMode::OpenLineAbove)
-                    pos = buffer.char_prev(pos);
-                else
-                {
-                    auto pos_non_blank = buffer.iterator_at(pos);
-                    while (*pos_non_blank == ' ' or *pos_non_blank == '\t')
-                        ++pos_non_blank;
-                    if (*pos_non_blank != '\n')
-                        pos = pos_non_blank.coord();
-                }
+                auto pos_non_blank = buffer.iterator_at(pos);
+                while (*pos_non_blank == ' ' or *pos_non_blank == '\t')
+                    ++pos_non_blank;
+                if (*pos_non_blank != '\n')
+                    pos = pos_non_blank.coord();
                 sel = pos;
             }
             break;
         case InsertMode::InsertAtNextLineBegin:
         case InsertMode::InsertCursor:
-             kak_assert(false); // not implemented
+             kak_assert(false); // invalid for interactive insert
              break;
         }
-        if (mode == InsertMode::OpenLineBelow or mode == InsertMode::OpenLineAbove)
-        {
-            insert('\n');
-            if (mode == InsertMode::OpenLineAbove)
-            {
-                for (auto& sel : selections)
-                {
-                    // special case, the --first line above did nothing, so we need to compensate now
-                    if (sel.anchor() == buffer.char_next({0,0}))
-                        sel = Selection{{0,0}};
-                }
-            }
-        }
         selections.sort_and_merge_overlapping();
         selections.check_invariant();
         buffer.check_invariant();