improve cursor restoring on whitespace

[lisp-parkour.git] / edit.lua

local M = {}

-- XXX: in Lua 5.2 unpack() was moved into table
local unpack = unpack or table.unpack

local function startof(node) return node.start end
local function finishof(node) return node.finish end
local function is_comment(node) return node.is_comment end

function M.new(parser, walker, fmt, write, delete, eol_at)

        local function is_line_comment(node) return node.is_comment and parser.opposite[node.d] == "\n" end

        local function normalize_spacing(start, delta, list)
                if delta > 0 then
                        table.insert(list, {start + delta, -delta})
                elseif delta < 0 then
                        table.insert(list, {start, -delta})
                end
                return delta
        end

        local function leading_space(s, deltas, adj, parent, i, pstart, has_eol)
                local prev = parent[i - 1]
                if not s.indent and not (prev and (s.d == "|" or prev.d == "|")) and not has_eol then
                        local off = prev and prev.finish + 1 or pstart
                        adj = adj + normalize_spacing(off, s.start - off - (prev and 1 or 0), deltas)
                end
                return adj
        end

        local function trailing_space(s, deltas, adj, parent, i, has_eol, keep_electric_space)
                local nxt = parent[i + 1]
                local is_last = not nxt
                if (is_last and not keep_electric_space) or nxt and nxt.indent then
                        local off = is_last and parent.finish - (has_eol and i < #parent and 1 or 0) or nxt.start - nxt.indent - 1
                        local finish = s.finish + (has_eol and i < #parent and 0 or 1)
                        normalize_spacing(finish, off - finish, deltas)
                end
                return adj
        end

        local function indentation(s, deltas, adj, parent, i, pstart, base_indent, last_distinguished, first_argument,
                op_adj, indent_adj)
                if s.indent then
                        local delta = base_indent - s.indent
                        local firstarg_delta = base_indent + parent[1].finish + 2 - pstart - s.indent - op_adj - (indent_adj or 0)
                        if last_distinguished and i > 1 then
                                delta = delta + 1
                                if i - 1 <= last_distinguished then
                                        if parent[first_argument + 1].indent then
                                                delta = delta + 2
                                        else
                                                delta = firstarg_delta
                                        end
                                elseif last_distinguished < 0
                                        and i > first_argument + 1 and not parent[first_argument + 1].indent then
                                        delta = firstarg_delta
                                end
                        elseif i == 1 then
                                -- remove leading space, if any
                                delta = -(s.start - pstart)
                        elseif                               -- align further arguments below the second one
                                parent.d == "("              -- [] and {} contain data, so no arguments
                                and not parent[1].is_string  -- a string can't have arguments
                                --and not parent[1].is_list  -- wrong, GNU Emacs compatible behaviour
                                then
                                if i > first_argument + 1 and not parent[first_argument + 1].indent then
                                        delta = firstarg_delta
                                end
                                if delta < 0 then delta = math.max(-s.indent, delta) end
                        end
                        if delta ~= 0 then
                                table.insert(deltas, {s.start, delta})
                        end
                        adj = adj - delta
                end
                return adj
        end

        local function refmt_list(parent, base_indent, padj, deltas, keep_electric_space)
                local adj = 0
                local op_adj = 0
                local indent_adj = 0
                local pstart = parent.start + (parent.p and #parent.p or 0) + #parent.d
                if parent.is_empty then
                        normalize_spacing(pstart, parent.finish - pstart, deltas)
                        return deltas
                end
                local last_distinguished = fmt:last_distinguished(parent)
                local first_argument = 1
                if #parent > 2 and parent[1].is_list and #parent[1] > 1 then
                        local op = parent[1]
                        local nearest_indented = op[#op].indent and op[#op] or walker.indented_before(op[#op])
                        indent_adj = nearest_indented.start - pstart - nearest_indented.indent + 1
                end
                for i, s in ipairs(parent) do
                        adj = s.indent and 0 or adj
                        if last_distinguished then
                                -- do not let early comments influence the indentation of real expressions:
                                if i <= last_distinguished and s.is_comment then
                                        last_distinguished = last_distinguished + 1
                                end
                                -- s is the name of a named let. account for it:
                                if i == last_distinguished + 1 and not s.is_list and parent[1].text == "let" then
                                        last_distinguished = last_distinguished + 1
                                end
                                -- do not let early comments influence the indentation of real expressions:
                        elseif i <= first_argument + 1 and s.is_comment then
                                first_argument = first_argument + 1
                        end
                        local has_eol = is_line_comment(s)
                        adj = leading_space(s, deltas, adj, parent, i, pstart, has_eol)
                        adj = trailing_space(s, deltas, adj, parent, i, has_eol, keep_electric_space)
                        adj = indentation(s, deltas, adj, parent, i, pstart, base_indent, last_distinguished, first_argument,
                                op_adj, indent_adj)
                        if i == 1 then
                                op_adj = adj
                        end
                        if s.is_list then
                                local nearest_indented = s.indent and s or walker.indented_before(s)
                                local parent_column = nearest_indented and
                                        nearest_indented.indent + (s.start + (s.p and #s.p or 0) + #s.d) - nearest_indented.start
                                        or base_indent + (s.start + (s.p and #s.p or 0) + #s.d) - pstart
                                refmt_list(s, parent_column - adj, padj + adj, deltas, keep_electric_space)
                        end
                end
                return deltas
        end

        local function refmt_at(scope, range, keep_electric_space)
                if not range or not scope or not scope.start or not scope.finish or
                        (scope.finish - scope.start < 3) or scope.is_root then return range.start end
                local parent = walker.sexp_at(scope, true)
                if not (parent and parent.is_list) then return range.start end
                local _, parent_at, m = walker.sexp_at(range, true)
                local path
                if parent_at[m] then
                        path = walker.sexp_path(parent_at[m])
                        local base = parent_at[m]
                        if range.finish == base.finish + 1 then
                                path.after_finish = 0  -- lists can end up with a different length
                        else
                                path.after_start = range.start - base.start
                        end
                else
                        local s = parent_at[#parent_at]
                        if not s or range.start >= s.finish + 1 + (is_line_comment(s) and 1 or 0) then
                                path = walker.sexp_path(parent_at)
                                path.at_pfinish = true
                        else
                                local prev, n = parent_at.before(range.start, finishof)
                                if prev then
                                        path = walker.sexp_path(prev)
                                        local nxt = parent_at[n + 1]
                                        path.after_finish = nxt and not nxt.indent and 1 or range.finish - prev.finish - 1
                                else
                                        path = walker.sexp_path(parent_at[1])
                                        path.after_start = 0
                                end
                        end
                end
                local indented_parent = parent.indent and parent or parent.is_list and walker.indented_before(parent)
                local parent_column = indented_parent and (indented_parent.indent + parent.start - indented_parent.start +
                        (parent.p and #parent.p or 0) + #parent.d) or
                        0
                local deltas = refmt_list(parent, parent_column, 0, {}, keep_electric_space)
                table.sort(deltas, function(d1, d2) return d1[1] > d2[1] end)
                for _, pair in ipairs(deltas) do
                        local offset, delta = unpack(pair)
                        if delta > 0 then
                                write(offset, string.rep(" ", delta))
                        elseif delta < 0 then
                                delete(offset + delta, -delta)
                        end
                end
                parser.tree.rewind(parent.start or 0)
                if path then
                        local sexp, parentng, n = walker.goto_path(path)
                        if sexp then
                                if path.after_finish then
                                        local nxt = n and parentng[n + 1]
                                        local max = nxt and nxt.start - sexp.finish - 1
                                        return sexp.finish + 1 - (range.finish - range.start) +
                                                (max and math.min(path.after_finish, max) or path.after_finish)
                                elseif path.at_pfinish then
                                        return sexp.finish
                                else
                                        return sexp.start + path.after_start
                                end
                        end
                end
                return range.start
        end

        local function splice(pos, sexps, skip, backwards, action)
                local spliced
                local sexp = walker.sexp_at(skip, true)
                local start = sexp.start + (sexp.p and #sexp.p or 0)
                -- XXX: don't splice empty line comments _yet_; see _join_or_splice
                local tosplice = action.splice or action.wrap or not is_line_comment(sexp) and sexp.is_empty
                local opening = (sexp.p or '')..sexp.d
                local closing = parser.opposite[sexp.d]
                local real_start = tosplice and sexp.start or start + #sexp.d
                local splice_closing = closing ~= "\n" or sexp.is_empty
                local real_finish = sexp.finish + 1 - (tosplice and splice_closing and 0 or #closing)
                local first = backwards and
                        {start = real_start, finish = math.max(pos, start + #sexp.d)} or
                        {start = real_start, finish = sexp.is_empty and pos or start + #sexp.d}
                local second = backwards and
                        {start = sexp.is_empty and pos or sexp.finish + 1 - #closing, finish = real_finish} or
                        {start = math.min(pos, sexp.finish + 1 - #closing), finish = real_finish}
                action.func(second)
                action.func(first)
                spliced = tosplice
                if action.kill then
                        local ndeleted = first.finish - first.start + second.finish - second.start
                        if ndeleted > 0 then
                                sexps.rewind(sexp.start)
                        end
                end
                return first.finish - first.start, spliced, opening, closing
        end

        -- If you try to delete some part of indentation, this function joins the current line with
        -- the previous one, unless the latter is a line comment.
        -- it does this by
        -- a) extending or shrinking the range that is to be deleted
        -- b) returning a truthy value to trick pick_out to glide the cursor, but refmt to restore the deleted spaces
        -- c) both a) and b)
        local function delete_indentation(range, pos)
                local node, parent = walker.sexp_at(range)
                if node or not parent.is_list then return end
                local prev = parent.before(pos, finishof)
                local nxt = parent.after(pos, startof)
                if prev and prev.finish >= range.start or nxt and nxt.start < range.finish then return end
                local backwards = pos == range.finish
                local adj = 0
                local eol = eol_at(pos)
                local on_empty_line = not nxt or eol and nxt.start > eol
                local empty_line_after_comment = prev and is_line_comment(prev)
                        and on_empty_line
                if nxt and nxt.indent then
                        if backwards and prev then
                                range.start = prev.finish + (empty_line_after_comment and 0 or 1)
                                if not prev.d then
                                        range.finish = range.start + 1
                                        adj = (on_empty_line and 0 or 1)
                                end
                        end
                        return adj
                end
                if not nxt and prev then
                        range.start = prev.finish + 1
                        range.finish = parent.finish
                elseif nxt and nxt.start == range.finish and (not prev or prev.finish + 1 == range.start) then
                        if prev and prev.d or nxt and nxt.d then
                                -- don't delete spaces near delimiters, just slide the cursor:
                                if backwards then
                                        range.finish = range.start
                                else
                                        range.start = range.finish
                                end
                        end
                        return adj
                end
        end

        local function big_enough_parent(pos1, pos2)
                -- since the pos1-pos2 range can cross list boundaries, find which list contains both pos1 and pos2
                local _, p1, p2
                _, p1 = walker.sexp_at({start = pos1, finish = pos1}, true)
                if p1.is_root or not (p1.start < pos1 and p1.finish > pos2) then
                        _, p2 = walker.sexp_at({start = pos2, finish = pos2}, true)
                end
                return p2 and not p2.is_root and p2 or p1
        end

        local function extend_overlap(range)
                local rnode = walker.sexp_at({start = range.finish, finish = range.finish})
                if rnode and rnode.p and rnode.p:find"[;\\]"
                        and range.finish > rnode.start and range.finish < rnode.start + #rnode.p then
                        return {start = range.start, finish = rnode.start + #rnode.p}
                end
                rnode = walker.sexp_at({start = range.start, finish = range.start})
                if rnode and rnode.p and rnode.p:find"\\"
                        and range.start == rnode.start + #rnode.p then
                        return {start = rnode.start, finish = range.finish}
                end
                return range
        end

        local function pick_out(range, pos, action)
                local ndeleted = 0
                if range.start == range.finish then return ndeleted end
                local sexps = parser.tree
                local skips = sexps.unbalanced_delimiters(range)
                -- handle splice and kill-splice of forms and strings:
                if #skips == 1 then
                        local sexp = walker.sexp_at(skips[1], true)
                        local backward_splice = skips[1].opening and pos >= sexp.start + (sexp.p and #sexp.p or 0) + #sexp.d
                                and range.start >= sexp.start
                        local forward_splice = skips[1].closing and pos <= sexp.finish + 1 - #parser.opposite[sexp.d]
                                and range.finish <= sexp.finish + 1
                        if backward_splice or forward_splice then
                                return splice(backward_splice and range.finish or range.start, sexps, sexp, backward_splice, action)
                        end
                end
                local node, parent = walker.sexp_at({start = range.finish, finish = range.finish})
                -- if the range ends with a line comment, don't delete its closing newline:
                local drop_eol = action.kill and node and
                        node.finish + 1 == range.finish and is_line_comment(node)
                local par = big_enough_parent(range.start, range.finish)
                local operator_changed = par[1] and par[1].finish >= range.start
                local refmt = #skips == 0 and delete_indentation(range, pos) or operator_changed and 0
                table.sort(skips, function(a, b) return a.start < b.start end)
                table.insert(skips, {start = range.finish - (drop_eol and 1 or 0)})
                table.insert(skips, 1, {finish = range.start})
                ndeleted = ndeleted + (drop_eol and 1 or 0)
                for i = #skips - 1, 1, -1 do
                        local region = {start = skips[i].finish, finish = skips[i + 1].start}
                        if skips[i].closing and skips[i + 1].opening then
                                -- leave out some of the space between adjacent lists
                                local _, rparent = walker.sexp_at(region)
                                local nxt = rparent.after(region.start, startof)
                                region.start = nxt and nxt.start or region.start
                        end
                        if action then
                                action.func(region)
                                ndeleted = ndeleted + (region.finish - region.start)
                        end
                end
                -- if parent[#parent + 1] is nil, we are at EOF
                if ndeleted > 0 and (not parent.is_root or parent.is_parsed(range.start) or parent[#parent + 1]) then
                        sexps.rewind(range.start)
                end
                return ndeleted - (refmt or 0), nil, nil, nil, refmt
        end

        local function raise_sexp(range, pos)
                local sexp, parent = walker.sexp_at(range, true)
                if sexp and parent and parent.is_list then
                        delete(sexp.finish + 1, parent.finish - sexp.finish)
                        delete(parent.start, sexp.start - parent.start)
                        parser.tree.rewind(parent.start)
                        range.start = parent.start + pos - sexp.start
                        range.finish = range.start
                        local _, nodes = walker.sexp_path(range)
                        local grandparent = nodes[#nodes - 2]
                        return grandparent and refmt_at(grandparent, range) or range.start
                end
        end

        local function slurp_sexp(range, forward)
                local _, parent = walker.sexp_at(range, true)
                local seeker = forward and walker.finish_after or walker.start_before
                if not parent or not parent.is_list then return range.start end
                local r = {start = parent.start, finish = parent.finish + 1}
                local newpos = seeker(r, is_comment)
                if not newpos then return range.start end
                local opening = (parent.p or '')..parent.d
                local closing = parser.opposite[parent.d]
                local delimiter = forward and closing or opening
                if forward then
                        write(newpos, delimiter)
                end
                delete(forward and parent.finish or parent.start, #delimiter)
                if not forward then
                        write(newpos, delimiter)
                end
                parser.tree.rewind(math.min(parent.start, newpos))
                return refmt_at(big_enough_parent(newpos, range.start), range) or range.start
        end

        local function barf_sexp(range, forward)
                local _, parent, m = walker.sexp_at(range, true)
                local seeker = forward and walker.finish_before or walker.start_after
                -- TODO: barfing out of strings requires calling the parser on them
                if not parent or not parent.is_list then return range.start end
                local opening = (parent.p or '')..parent.d
                local pstart = parent.start + #opening
                local r = {start = forward and parent.finish - 1 or pstart, finish = forward and parent.finish or pstart + 1}
                local newpos = seeker(r, is_comment) or forward and pstart or parent.finish
                if not newpos then return range.start end
                local closing = parser.opposite[parent.d]
                local delimiter = forward and closing or opening
                if not forward then
                        write(newpos, delimiter)
                end
                delete(forward and parent.finish or parent.start, #delimiter)
                if forward then
                        write(newpos, delimiter)
                end
                parser.tree.rewind(math.min(parent.start, newpos))
                local barfed_cursor_backward = m == 1 and not forward
                local barfed_cursor_forward = m == #parent and forward
                range.start = range.start + #delimiter * (barfed_cursor_backward and -1 or barfed_cursor_forward and 1 or 0)
                return refmt_at(big_enough_parent(newpos, parent.finish + 1), range) or range.start
        end

        local function splice_sexp(range, _, no_refmt)
                local _, parent = walker.sexp_at(range)
                if not parent or not parent.d then return end
                local opening = (parent.p or '')..parent.d
                local closing = parser.opposite[parent.d]
                local finish = parent.finish + 1 - #closing
                if closing ~= "\n" then
                        delete(finish, #closing)
                end
                -- TODO: (un)escape special characters, if necessary
                delete(parent.start, parent.is_empty and (finish - parent.start) or #opening)
                parser.tree.rewind(parent.start)
                range.start = range.start - #opening
                range.finish = range.start
                local _, parentng = walker.sexp_at(range, true)
                return not no_refmt and refmt_at(parentng, range) or range.start
        end

        local function rewrap(parent, kind)
                local pstart = parent.start + #((parent.p or '')..parent.d) - 1
                delete(parent.finish, 1)
                write(parent.finish, parser.opposite[kind])
                delete(pstart, #parent.d)
                write(pstart, kind)
                parser.tree.rewind(parent.start)
        end

        local function cycle_wrap(range, pos)
                local _, parent = walker.sexp_at(range)
                if not parent or not parent.is_list then return end
                local next_kind = {["("] = "[", ["["] = "{", ["{"] = "("}
                rewrap(parent, next_kind[parent.d])
                return pos
        end

        local function split_sexp(range)
                local _, parent = walker.sexp_at(range)
                if not (parent and parent.d) then return end
                local new_finish, new_start
                if parent.is_list then
                        local prev = parent.before(range.start, finishof, is_comment)
                        new_finish = prev and prev.finish + 1
                        -- XXX: do not skip comments here, so they end up in the second list
                        -- and are not separated from their target expression:
                        local nxt = new_finish and parent.after(new_finish, startof)
                        new_start = nxt and nxt.start
                else
                        new_start = range.start
                        new_finish = range.start
                end
                if not (new_start and new_finish) then return end
                local opening = (parent.p or '')..parent.d
                local closing = parser.opposite[parent.d]
                write(new_start, opening)
                local sep = is_line_comment(parent) and ""  -- line comments already have a separator
                        or new_finish == new_start and " "  -- only add a separator if there was none before
                        or ""
                write(new_finish, closing..sep)
                parser.tree.rewind(parent.start)
                range.start = new_start + (parent.is_list and 0 or #opening + #closing)
                range.finish = range.start
                local _, nodes = walker.sexp_path(range)
                local parentng, grandparent = nodes[#nodes - 1], nodes[#nodes - 2]
                local scope = parentng and not parentng.is_root and parentng or grandparent
                return refmt_at(scope, range) or range.start
        end

        local function join_sexps(range)
                local node, parent = walker.sexp_at(range, true)
                local first = node and node.finish + 1 == range.start and node or parent.before(range.start, finishof)
                local second = first ~= node and node or parent.after(range.start, startof)
                if not (first and second and first.d and
                        -- don't join line comments to margin comments:
                        (not is_line_comment(first) or first.indent and second.indent) and
                        (first.d == second.d or
                                -- join line comments even when their delimiters differ slightly
                                -- (different number of semicolons, existence/lack of a space after them)
                                parser.opposite[first.d] == parser.opposite[second.d])) then
                        return
                end
                local opening = (second.p or '')..second.d
                local closing = parser.opposite[first.d]
                local pos
                if not first.is_list then
                        pos = first.finish + 1 - #closing
                        delete(pos, second.start + #opening - pos)
                else
                        delete(second.start, #opening)
                        delete(first.finish, #closing)
                        pos = second.start - #closing
                end
                parser.tree.rewind(first.start)
                range.start = pos
                range.finish = range.start
                local _, nodes = walker.sexp_path(range)
                local parentng, grandparent = nodes[#nodes - 1], nodes[#nodes - 2]
                local scope = parentng and not parentng.is_root and parentng or grandparent
                return refmt_at(scope, range) or range.start
        end

        local function delete_splicing(range, pos, splicing, delete_and_yank)
                local action = {kill = true, wrap = splicing, splice = splicing, func = delete_and_yank}
                local sexp, parent, n = walker.sexp_at(range, true)
                range = extend_overlap(range)
                local ndeleted, spliced = pick_out(range, pos, action)
                local closing = spliced and parser.opposite[sexp.d]
                local inner_list_len = spliced and sexp.finish - sexp.start + 1 - #sexp.d - #closing
                local range_len = range.finish - range.start
                local backwards = pos == range.finish
                local whole_object = sexp and
                        (sexp.start == range.start and sexp.finish + 1 == range.finish
                        or spliced and (inner_list_len <= (backwards and range_len + ndeleted or range_len)))
                local in_head_atom = sexp and not sexp.d and n == 1 and #parent > 1
                local in_whitespace = not sexp
                if whole_object or in_whitespace or in_head_atom then
                        local cur = whole_object and sexp.start or range.start
                        -- if parent[#parent + 1] is nil, we are at EOF
                        if not parent.is_root or parent.is_parsed(cur) or parent[#parent + 1] then
                                parser.tree.rewind(cur)
                        end
                        local r = {start = cur, finish = cur}
                        local _, parentng = walker.sexp_at(r, true)
                        local newpos = refmt_at(parentng, r)
                        return newpos or cur
                end
                return spliced and (backwards and sexp.start or range.start - ndeleted)
                        or not backwards and ndeleted <= 0 and range.finish - ndeleted
                        or range.start
        end

        local function transpose(range, first, second)
                if not (first and second) then return end
                local copy1 = first.text
                local copy2 = second.text
                delete(second.start, second.finish + 1 - second.start)
                write(second.start, copy1)
                delete(first.start, first.finish + 1 - first.start)
                write(first.start, copy2)
                parser.tree.rewind(first.start)
                range.start = second.finish + 1
                range.finish = range.start
                return refmt_at(big_enough_parent(first.start, second.finish), range) or range.start
        end

        local function transpose_sexps(range)
                local node, parent = walker.sexp_at(range, true)
                local first = node and node.finish + 1 == range.start and node or parent.before(range.start, finishof)
                local second = first ~= node and node or parent.after(range.start, startof)
                return transpose(range, first, second)
        end

        local function transpose_words(range)
                local _, first = walker.start_float_before(range)
                local _, second = walker.finish_float_after(range)
                if first and second and first.start == second.start then
                        _, first = walker.start_float_before(first)
                end
                return transpose(range, first, second)
        end

        local function transpose_chars(range)
                local node, parent, i = walker.sexp_at(range)
                local nxt = i and parent[i + 1]
                local pstart = not parent.is_root and parent.start + (parent.p and #parent.p or 0) + #parent.d
                local pfinish = not parent.is_root and parent.finish
                local npref = node and node.p and node.start + #node.p
                -- only allow transposing while inside atoms/words and prefixes
                if node and ((npref and (range.start <= npref and range.start > node.start) or
                        node.d and range.start > node.finish + 1) or not node.d and (not pstart or range.start > pstart)) then
                        local start = range.start -
                                ((range.start == pfinish or range.start == npref or
                                range.start == node.finish + 1 and (parent.is_list or parent.is_root) and (not nxt or nxt.indent)) and 1 or 0)
                        local str_start = start - node.start + 1
                        local char = node.text:sub(str_start, str_start)
                        delete(start, 1)
                        write(start - 1, #char > 0 and char or " ")
                        parser.tree.rewind(start)
                        local in_head_atom = i == 1 and #parent > 1
                        return parent.is_list and in_head_atom
                                and refmt_at(parent, {start = start + 1, finish = start + 1})
                                or start + 1
                end
        end

        local function _join_or_splice(parent, n, range, pos)
                local sexp = parent[n]
                local nxt = parent[n + 1]
                local is_last = not nxt or not is_line_comment(nxt)
                local newpos = not (is_last and sexp.is_empty) and join_sexps(range)
                if not newpos and sexp.is_empty then
                        newpos = splice_sexp({start = pos, finish = pos}, nil, true)
                end
                return newpos or pos
        end

        local function delete_nonsplicing(range, pos, delete_maybe_yank)
                local action = {kill = true, wrap = false, splice = false, func = delete_maybe_yank}
                range = extend_overlap(range)
                local ndeleted, spliced, opening, _, refmt = pick_out(range, pos, action)
                local backwards = pos == range.finish
                if opening then
                        if spliced then
                                return pos - ndeleted
                        else
                                if ndeleted == 0 then
                                        local closing = parser.opposite[opening] -- XXX: why don't I use the pick_out return value?
                                        if closing == "\n" then
                                                local sexp, parent, n = walker.sexp_at(range)
                                                if pos == sexp.start + #sexp.d and backwards then
                                                        return _join_or_splice(parent, n, range, pos)
                                                elseif pos == sexp.finish then
                                                        local r = {start = pos + #closing, finish = pos + #closing}
                                                        return _join_or_splice(parent, n, r, pos)
                                                end
                                        end
                                end
                                return backwards and (range.finish - ndeleted) or range.start
                        end
                else
                        local newpos = backwards and range.start or (range.finish - ndeleted)
                        if refmt then
                                local r = {start = newpos, finish = newpos}
                                return refmt_at(big_enough_parent(range.start, range.finish - ndeleted), r, true) or newpos
                        end
                        return newpos
                end
        end

        local function insert_pair(range, delimiter, shiftless, auto_square)
                local indices, nodes = walker.sexp_path(range)
                local sexp = nodes[#nodes]
                local right_after_prefix = sexp and sexp.p and range.start == sexp.start + #sexp.p
                -- XXX: here I assume that # is a valid prefix for the dialect
                local mb_closing = (delimiter == "|") and right_after_prefix and parser.opposite[sexp.p .. delimiter]
                local closing = mb_closing or parser.opposite[delimiter]
                local squarewords = fmt.squarewords
                if squarewords and not right_after_prefix
                        and not (closing == "]" and shiftless and not auto_square)
                        and (auto_square or squarewords.not_optional)
                        and not fmt:adjust_bracket_p(indices, nodes, range) then
                                delimiter, closing = "[", "]"
                end
                write(range.finish, closing)
                write(range.start, delimiter)
                if right_after_prefix or parser.tree.is_parsed(range.start) then
                        parser.tree.rewind(right_after_prefix and sexp.start or range.start)
                end
                return range.start + #delimiter
        end

        local function make_wrap(kind)
                return function(range, pos, auto_square)
                        local opening = kind
                        local function _wrap(r)
                                if not (r.finish > r.start) then return end
                                insert_pair(r, opening, false, auto_square)
                        end
                        local action = {kill = false, wrap = false, splice = false, func = _wrap}
                        pick_out(range, pos, action)
                        range.start = range.start + #opening
                        return refmt_at(big_enough_parent(range.start - #opening, range.start), range) or range.start
                end
        end

        local function newline(parent, range)
                local line_comment = is_line_comment(parent)
                -- do not autoextend margin comments:
                if line_comment and range.start < parent.finish + (parent.indent and 1 or 0)  then
                        local newpos = split_sexp(range)
                        if newpos then
                                return newpos
                        end
                end
                if not parent.is_list and not line_comment then
                        -- if parent[#parent + 1] is nil, we are at EOF
                        if not parent.is_root or parent.is_parsed(range.start) or parent[#parent + 1] then
                                parser.tree.rewind(parent.start or range.start)
                        end
                        local newpos = range.start
                        write(newpos, "\n")
                        return newpos + 1
                end
                if not parent.is_list then
                        local _
                        _, parent = walker.sexp_at(parent, true)
                end
                local last_nonblank_in_list = not parent.is_empty and parent[#parent].finish - (line_comment and 1 or 0)
                local nxt = parent.after(range.start, startof)
                local last_on_line = not nxt or nxt and nxt.indent and nxt.start > range.start
                local margin = nxt and not nxt.indent and is_line_comment(nxt) and nxt.finish
                local after_last = last_nonblank_in_list and range.start > last_nonblank_in_list
                local in_indent = nxt and nxt.indent and range.start <= nxt.start and range.start >= (nxt.start - nxt.indent)
                local placeholder = "asdf"
                local newpos = margin or range.start
                if not parent.is_empty then
                        if in_indent then
                                write(newpos, (placeholder.."\n"))
                        else
                                write(newpos, "\n"..((after_last or last_on_line or margin) and placeholder or ""))
                        end
                end
                parser.tree.rewind(parent.start or newpos)
                -- move the cursor onto the placeholder, so refmt_at can restore the position:
                local r = {start = newpos, finish = newpos}
                newpos = walker.start_after(r) or newpos
                local rangeng = {start = newpos, finish = newpos}
                newpos = refmt_at(parent, rangeng) or rangeng.start
                local _, parentng = walker.sexp_at({start = newpos, finish = newpos}, true)
                if after_last then
                        local autoindent = parentng[#parentng].indent
                        write(parentng.finish, "\n"..string.rep(" ", autoindent or 0))
                end
                if after_last or last_on_line or margin or in_indent then
                        delete(newpos, #placeholder)
                end
                parser.tree.rewind(parentng.start or newpos)
                return newpos
        end

        local function close_and_newline(range, closing)
                local opening = closing and parser.opposite[closing]
                local parent = walker.quasilist_at(range, opening)
                if parent then
                        local has_eol = is_line_comment(parent)
                        local r = {start = parent.finish, finish = parent.finish}
                        local newpos = refmt_at(parent, r) or r.start
                        r = {start = newpos + (has_eol and 0 or 1), finish = newpos + (has_eol and 0 or 1)}
                        local list, parentng = walker.sexp_at(r)
                        newpos = list and list.finish + 1 or r.start
                        newpos = newline(parentng, {start = newpos, finish = newpos})
                        if not newpos then
                                newpos = r.finish + 1
                                write(newpos, "\n")
                                parser.tree.rewind(parentng.start or list.start)
                        end
                        return newpos
                elseif closing == "\n" then
                        local eol = eol_at(range.start)
                        local _, parentng = walker.sexp_at({start = eol, finish = eol})
                        local newpos = newline(parentng, {start = eol, finish = eol})
                        return newpos
                end
                return range.start
        end

        local function join_line(_, pos)
                local eol = eol_at(pos)
                local r = {start = eol, finish = eol + 1}
                return delete_nonsplicing(r, r.start, delete)
        end

        local wrap_doublequote = make_wrap'"'

        local function meta_doublequote(range, pos, auto_square)
                local escaped = walker.escaped_at(range)
                if not escaped then
                        return wrap_doublequote(range, pos, auto_square)
                elseif escaped.is_string then
                        return close_and_newline(range, '"')
                end
                return pos
        end

        return {
                delete_splicing = delete_splicing,
                delete_nonsplicing = delete_nonsplicing,
                refmt_at = refmt_at,
                pick_out = pick_out,
                raise_sexp = raise_sexp,
                slurp_sexp = slurp_sexp,
                barf_sexp = barf_sexp,
                splice_sexp = splice_sexp,
                wrap_round = make_wrap"(",
                wrap_square = make_wrap"[",
                wrap_curly = make_wrap"{",
                meta_doublequote = meta_doublequote,
                insert_pair = insert_pair,
                newline = newline,
                join_line = join_line,
                close_and_newline = close_and_newline,
                cycle_wrap = cycle_wrap,
                split_sexp = split_sexp,
                join_sexps = join_sexps,
                transpose_sexps = transpose_sexps,
                transpose_words = transpose_words,
                transpose_chars = transpose_chars,
        }
end

return M