From 186a559818f7a709dbdd4590fe7440ebd619a208 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Fri, 4 Mar 2022 16:18:58 +0100
Subject: refactor(lua): move only runtime lua file in src/ to runtime/lua

reorganize so that initialization is done in lua
---
 runtime/lua/vim/_editor.lua | 659 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 659 insertions(+)
 create mode 100644 runtime/lua/vim/_editor.lua

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
new file mode 100644
index 0000000000..5f3329ef42
--- /dev/null
+++ b/runtime/lua/vim/_editor.lua
@@ -0,0 +1,659 @@
+-- Nvim-Lua stdlib: the `vim` module (:help lua-stdlib)
+--
+-- Lua code lives in one of three places:
+--    1. runtime/lua/vim/ (the runtime): For "nice to have" features, e.g. the
+--       `inspect` and `lpeg` modules.
+--    2. runtime/lua/vim/shared.lua: Code shared between Nvim and tests.
+--       (This will go away if we migrate to nvim as the test-runner.)
+--    3. src/nvim/lua/: Compiled-into Nvim itself.
+--
+-- Guideline: "If in doubt, put it in the runtime".
+--
+-- Most functions should live directly in `vim.`, not in submodules.
+-- The only "forbidden" names are those claimed by legacy `if_lua`:
+--    $ vim
+--    :lua for k,v in pairs(vim) do print(k) end
+--    buffer
+--    open
+--    window
+--    lastline
+--    firstline
+--    type
+--    line
+--    eval
+--    dict
+--    beep
+--    list
+--    command
+--
+-- Reference (#6580):
+--    - https://github.com/luafun/luafun
+--    - https://github.com/rxi/lume
+--    - http://leafo.net/lapis/reference/utilities.html
+--    - https://github.com/torch/paths
+--    - https://github.com/bakpakin/Fennel (pretty print, repl)
+--    - https://github.com/howl-editor/howl/tree/master/lib/howl/util
+
+local vim = assert(vim)
+assert(vim.inspect)
+
+-- These are for loading runtime modules lazily since they aren't available in
+-- the nvim binary as specified in executor.c
+setmetatable(vim, {
+  __index = function(t, key)
+    if key == 'treesitter' then
+      t.treesitter = require('vim.treesitter')
+      return t.treesitter
+    elseif key == 'filetype' then
+      t.filetype = require('vim.filetype')
+      return t.filetype
+    elseif key == 'F' then
+      t.F = require('vim.F')
+      return t.F
+    elseif require('vim.uri')[key] ~= nil then
+      -- Expose all `vim.uri` functions on the `vim` module.
+      t[key] = require('vim.uri')[key]
+      return t[key]
+    elseif key == 'lsp' then
+      t.lsp = require('vim.lsp')
+      return t.lsp
+    elseif key == 'highlight' then
+      t.highlight = require('vim.highlight')
+      return t.highlight
+    elseif key == 'diagnostic' then
+      t.diagnostic = require('vim.diagnostic')
+      return t.diagnostic
+    elseif key == 'keymap' then
+      t.keymap = require('vim.keymap')
+      return t.keymap
+    elseif key == 'ui' then
+      t.ui = require('vim.ui')
+      return t.ui
+    end
+  end
+})
+
+vim.log = {
+  levels = {
+    TRACE = 0;
+    DEBUG = 1;
+    INFO  = 2;
+    WARN  = 3;
+    ERROR = 4;
+  }
+}
+
+-- Internal-only until comments in #8107 are addressed.
+-- Returns:
+--    {errcode}, {output}
+function vim._system(cmd)
+  local out = vim.fn.system(cmd)
+  local err = vim.v.shell_error
+  return err, out
+end
+
+-- Gets process info from the `ps` command.
+-- Used by nvim_get_proc() as a fallback.
+function vim._os_proc_info(pid)
+  if pid == nil or pid <= 0 or type(pid) ~= 'number' then
+    error('invalid pid')
+  end
+  local cmd = { 'ps', '-p', pid, '-o', 'comm=', }
+  local err, name = vim._system(cmd)
+  if 1 == err and vim.trim(name) == '' then
+    return {}  -- Process not found.
+  elseif 0 ~= err then
+    error('command failed: '..vim.fn.string(cmd))
+  end
+  local _, ppid = vim._system({ 'ps', '-p', pid, '-o', 'ppid=', })
+  -- Remove trailing whitespace.
+  name = vim.trim(name):gsub('^.*/', '')
+  ppid = tonumber(ppid) or -1
+  return {
+    name = name,
+    pid = pid,
+    ppid = ppid,
+  }
+end
+
+-- Gets process children from the `pgrep` command.
+-- Used by nvim_get_proc_children() as a fallback.
+function vim._os_proc_children(ppid)
+  if ppid == nil or ppid <= 0 or type(ppid) ~= 'number' then
+    error('invalid ppid')
+  end
+  local cmd = { 'pgrep', '-P', ppid, }
+  local err, rv = vim._system(cmd)
+  if 1 == err and vim.trim(rv) == '' then
+    return {}  -- Process not found.
+  elseif 0 ~= err then
+    error('command failed: '..vim.fn.string(cmd))
+  end
+  local children = {}
+  for s in rv:gmatch('%S+') do
+    local i = tonumber(s)
+    if i ~= nil then
+      table.insert(children, i)
+    end
+  end
+  return children
+end
+
+-- TODO(ZyX-I): Create compatibility layer.
+
+--- Return a human-readable representation of the given object.
+---
+---@see https://github.com/kikito/inspect.lua
+---@see https://github.com/mpeterv/vinspect
+local function inspect(object, options)  -- luacheck: no unused
+  error(object, options)  -- Stub for gen_vimdoc.py
+end
+
+do
+  local tdots, tick, got_line1 = 0, 0, false
+
+  --- Paste handler, invoked by |nvim_paste()| when a conforming UI
+  --- (such as the |TUI|) pastes text into the editor.
+  ---
+  --- Example: To remove ANSI color codes when pasting:
+  --- <pre>
+  --- vim.paste = (function(overridden)
+  ---   return function(lines, phase)
+  ---     for i,line in ipairs(lines) do
+  ---       -- Scrub ANSI color codes from paste input.
+  ---       lines[i] = line:gsub('\27%[[0-9;mK]+', '')
+  ---     end
+  ---     overridden(lines, phase)
+  ---   end
+  --- end)(vim.paste)
+  --- </pre>
+  ---
+  ---@see |paste|
+  ---
+  ---@param lines  |readfile()|-style list of lines to paste. |channel-lines|
+  ---@param phase  -1: "non-streaming" paste: the call contains all lines.
+  ---              If paste is "streamed", `phase` indicates the stream state:
+  ---                - 1: starts the paste (exactly once)
+  ---                - 2: continues the paste (zero or more times)
+  ---                - 3: ends the paste (exactly once)
+  ---@returns false if client should cancel the paste.
+  function vim.paste(lines, phase)
+    local call = vim.api.nvim_call_function
+    local now = vim.loop.now()
+    local mode = call('mode', {}):sub(1,1)
+    if phase < 2 then  -- Reset flags.
+      tdots, tick, got_line1 = now, 0, false
+    elseif mode ~= 'c' then
+      vim.api.nvim_command('undojoin')
+    end
+    if mode == 'c' and not got_line1 then  -- cmdline-mode: paste only 1 line.
+      got_line1 = (#lines > 1)
+      vim.api.nvim_set_option('paste', true)  -- For nvim_input().
+      local line1 = lines[1]:gsub('<', '<lt>'):gsub('[\r\n\012\027]', ' ')  -- Scrub.
+      vim.api.nvim_input(line1)
+      vim.api.nvim_set_option('paste', false)
+    elseif mode ~= 'c' then
+      if phase < 2 and mode:find('^[vV\22sS\19]') then
+        vim.api.nvim_command([[exe "normal! \<Del>"]])
+        vim.api.nvim_put(lines, 'c', false, true)
+      elseif phase < 2 and not mode:find('^[iRt]') then
+        vim.api.nvim_put(lines, 'c', true, true)
+        -- XXX: Normal-mode: workaround bad cursor-placement after first chunk.
+        vim.api.nvim_command('normal! a')
+      elseif phase < 2 and mode == 'R' then
+        local nchars = 0
+        for _, line in ipairs(lines) do
+            nchars = nchars + line:len()
+        end
+        local row, col = unpack(vim.api.nvim_win_get_cursor(0))
+        local bufline = vim.api.nvim_buf_get_lines(0, row-1, row, true)[1]
+        local firstline = lines[1]
+        firstline = bufline:sub(1, col)..firstline
+        lines[1] = firstline
+        lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
+        vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
+      else
+        vim.api.nvim_put(lines, 'c', false, true)
+      end
+    end
+    if phase ~= -1 and (now - tdots >= 100) then
+      local dots = ('.'):rep(tick % 4)
+      tdots = now
+      tick = tick + 1
+      -- Use :echo because Lua print('') is a no-op, and we want to clear the
+      -- message when there are zero dots.
+      vim.api.nvim_command(('echo "%s"'):format(dots))
+    end
+    if phase == -1 or phase == 3 then
+      vim.api.nvim_command('redraw'..(tick > 1 and '|echo ""' or ''))
+    end
+    return true  -- Paste will not continue if not returning `true`.
+  end
+end
+
+--- Defers callback `cb` until the Nvim API is safe to call.
+---
+---@see |lua-loop-callbacks|
+---@see |vim.schedule()|
+---@see |vim.in_fast_event()|
+function vim.schedule_wrap(cb)
+  return (function (...)
+    local args = vim.F.pack_len(...)
+    vim.schedule(function() cb(vim.F.unpack_len(args)) end)
+  end)
+end
+
+-- vim.fn.{func}(...)
+vim.fn = setmetatable({}, {
+  __index = function(t, key)
+    local _fn
+    if vim.api[key] ~= nil then
+      _fn = function()
+        error(string.format("Tried to call API function with vim.fn: use vim.api.%s instead", key))
+      end
+    else
+      _fn = function(...)
+        return vim.call(key, ...)
+      end
+    end
+    t[key] = _fn
+    return _fn
+  end
+})
+
+vim.funcref = function(viml_func_name)
+  return vim.fn[viml_func_name]
+end
+
+-- An easier alias for commands.
+vim.cmd = function(command)
+  return vim.api.nvim_exec(command, false)
+end
+
+-- These are the vim.env/v/g/o/bo/wo variable magic accessors.
+do
+  local validate = vim.validate
+
+  --@private
+  local function make_dict_accessor(scope, handle)
+    validate {
+      scope = {scope, 's'};
+    }
+    local mt = {}
+    function mt:__newindex(k, v)
+      return vim._setvar(scope, handle or 0, k, v)
+    end
+    function mt:__index(k)
+      if handle == nil and type(k) == 'number' then
+        return make_dict_accessor(scope, k)
+      end
+      return vim._getvar(scope, handle or 0, k)
+    end
+    return setmetatable({}, mt)
+  end
+
+  vim.g = make_dict_accessor('g', false)
+  vim.v = make_dict_accessor('v', false)
+  vim.b = make_dict_accessor('b')
+  vim.w = make_dict_accessor('w')
+  vim.t = make_dict_accessor('t')
+end
+
+--- Get a table of lines with start, end columns for a region marked by two points
+---
+---@param bufnr number of buffer
+---@param pos1 (line, column) tuple marking beginning of region
+---@param pos2 (line, column) tuple marking end of region
+---@param regtype type of selection (:help setreg)
+---@param inclusive boolean indicating whether the selection is end-inclusive
+---@return region lua table of the form {linenr = {startcol,endcol}}
+function vim.region(bufnr, pos1, pos2, regtype, inclusive)
+  if not vim.api.nvim_buf_is_loaded(bufnr) then
+    vim.fn.bufload(bufnr)
+  end
+
+  -- check that region falls within current buffer
+  local buf_line_count = vim.api.nvim_buf_line_count(bufnr)
+  pos1[1] = math.min(pos1[1], buf_line_count - 1)
+  pos2[1] = math.min(pos2[1], buf_line_count - 1)
+
+  -- in case of block selection, columns need to be adjusted for non-ASCII characters
+  -- TODO: handle double-width characters
+  local bufline
+  if regtype:byte() == 22 then
+    bufline = vim.api.nvim_buf_get_lines(bufnr, pos1[1], pos1[1] + 1, true)[1]
+    pos1[2] = vim.str_utfindex(bufline, pos1[2])
+  end
+
+  local region = {}
+  for l = pos1[1], pos2[1] do
+    local c1, c2
+    if regtype:byte() == 22 then  -- block selection: take width from regtype
+      c1 = pos1[2]
+      c2 = c1 + regtype:sub(2)
+      -- and adjust for non-ASCII characters
+      bufline = vim.api.nvim_buf_get_lines(bufnr, l, l + 1, true)[1]
+      if c1 < #bufline then
+        c1 = vim.str_byteindex(bufline, c1)
+      end
+      if c2 < #bufline then
+        c2 = vim.str_byteindex(bufline, c2)
+      end
+    else
+      c1 = (l == pos1[1]) and (pos1[2]) or 0
+      c2 = (l == pos2[1]) and (pos2[2] + (inclusive and 1 or 0)) or -1
+    end
+    table.insert(region, l, {c1, c2})
+  end
+  return region
+end
+
+--- Defers calling `fn` until `timeout` ms passes.
+---
+--- Use to do a one-shot timer that calls `fn`
+--- Note: The {fn} is |schedule_wrap|ped automatically, so API functions are
+--- safe to call.
+---@param fn Callback to call once `timeout` expires
+---@param timeout Number of milliseconds to wait before calling `fn`
+---@return timer luv timer object
+function vim.defer_fn(fn, timeout)
+  vim.validate { fn = { fn, 'c', true}; }
+  local timer = vim.loop.new_timer()
+  timer:start(timeout, 0, vim.schedule_wrap(function()
+    timer:stop()
+    timer:close()
+
+    fn()
+  end))
+
+  return timer
+end
+
+
+--- Display a notification to the user.
+---
+--- This function can be overridden by plugins to display notifications using a
+--- custom provider (such as the system notification provider). By default,
+--- writes to |:messages|.
+---
+---@param msg string Content of the notification to show to the user.
+---@param level number|nil One of the values from |vim.log.levels|.
+---@param opts table|nil Optional parameters. Unused by default.
+function vim.notify(msg, level, opts) -- luacheck: no unused args
+  if level == vim.log.levels.ERROR then
+    vim.api.nvim_err_writeln(msg)
+  elseif level == vim.log.levels.WARN then
+    vim.api.nvim_echo({{msg, 'WarningMsg'}}, true, {})
+  else
+    vim.api.nvim_echo({{msg}}, true, {})
+  end
+end
+
+do
+  local notified = {}
+
+  --- Display a notification only one time.
+  ---
+  --- Like |vim.notify()|, but subsequent calls with the same message will not
+  --- display a notification.
+  ---
+  ---@param msg string Content of the notification to show to the user.
+  ---@param level number|nil One of the values from |vim.log.levels|.
+  ---@param opts table|nil Optional parameters. Unused by default.
+  function vim.notify_once(msg, level, opts) -- luacheck: no unused args
+    if not notified[msg] then
+      vim.notify(msg, level, opts)
+      notified[msg] = true
+    end
+  end
+end
+
+---@private
+function vim.register_keystroke_callback()
+  error('vim.register_keystroke_callback is deprecated, instead use: vim.on_key')
+end
+
+local on_key_cbs = {}
+
+--- Adds Lua function {fn} with namespace id {ns_id} as a listener to every,
+--- yes every, input key.
+---
+--- The Nvim command-line option |-w| is related but does not support callbacks
+--- and cannot be toggled dynamically.
+---
+---@param fn function: Callback function. It should take one string argument.
+---                   On each key press, Nvim passes the key char to fn(). |i_CTRL-V|
+---                   If {fn} is nil, it removes the callback for the associated {ns_id}
+---@param ns_id number? Namespace ID. If nil or 0, generates and returns a new
+---                    |nvim_create_namespace()| id.
+---
+---@return number Namespace id associated with {fn}. Or count of all callbacks
+---if on_key() is called without arguments.
+---
+---@note {fn} will be removed if an error occurs while calling.
+---@note {fn} will not be cleared by |nvim_buf_clear_namespace()|
+---@note {fn} will receive the keys after mappings have been evaluated
+function vim.on_key(fn, ns_id)
+  if fn == nil and ns_id == nil then
+    return #on_key_cbs
+  end
+
+  vim.validate {
+    fn = { fn, 'c', true},
+    ns_id = { ns_id, 'n', true }
+  }
+
+  if ns_id == nil or ns_id == 0 then
+    ns_id = vim.api.nvim_create_namespace('')
+  end
+
+  on_key_cbs[ns_id] = fn
+  return ns_id
+end
+
+--- Executes the on_key callbacks.
+---@private
+function vim._on_key(char)
+  local failed_ns_ids = {}
+  local failed_messages = {}
+  for k, v in pairs(on_key_cbs) do
+    local ok, err_msg = pcall(v, char)
+    if not ok then
+      vim.on_key(nil, k)
+      table.insert(failed_ns_ids, k)
+      table.insert(failed_messages, err_msg)
+    end
+  end
+
+  if failed_ns_ids[1] then
+    error(string.format(
+      "Error executing 'on_key' with ns_ids '%s'\n    Messages: %s",
+      table.concat(failed_ns_ids, ", "),
+      table.concat(failed_messages, "\n")))
+  end
+end
+
+--- Generate a list of possible completions for the string.
+--- String starts with ^ and then has the pattern.
+---
+---     1. Can we get it to just return things in the global namespace with that name prefix
+---     2. Can we get it to return things from global namespace even with `print(` in front.
+function vim._expand_pat(pat, env)
+  env = env or _G
+
+  pat = string.sub(pat, 2, #pat)
+
+  if pat == '' then
+    local result = vim.tbl_keys(env)
+    table.sort(result)
+    return result, 0
+  end
+
+  -- TODO: We can handle spaces in [] ONLY.
+  --    We should probably do that at some point, just for cooler completion.
+  -- TODO: We can suggest the variable names to go in []
+  --    This would be difficult as well.
+  --    Probably just need to do a smarter match than just `:match`
+
+  -- Get the last part of the pattern
+  local last_part = pat:match("[%w.:_%[%]'\"]+$")
+  if not last_part then return {}, 0 end
+
+  local parts, search_index = vim._expand_pat_get_parts(last_part)
+
+  local match_part = string.sub(last_part, search_index, #last_part)
+  local prefix_match_pat = string.sub(pat, 1, #pat - #match_part) or ''
+
+  local final_env = env
+
+  for _, part in ipairs(parts) do
+    if type(final_env) ~= 'table' then
+      return {}, 0
+    end
+    local key
+
+    -- Normally, we just have a string
+    -- Just attempt to get the string directly from the environment
+    if type(part) == "string" then
+      key = part
+    else
+      -- However, sometimes you want to use a variable, and complete on it
+      --    With this, you have the power.
+
+      -- MY_VAR = "api"
+      -- vim[MY_VAR]
+      -- -> _G[MY_VAR] -> "api"
+      local result_key = part[1]
+      if not result_key then
+        return {}, 0
+      end
+
+      local result = rawget(env, result_key)
+
+      if result == nil then
+        return {}, 0
+      end
+
+      key = result
+    end
+    local field = rawget(final_env, key)
+    if field == nil then
+      local mt = getmetatable(final_env)
+      if mt and type(mt.__index) == "table" then
+        field = rawget(mt.__index, key)
+      end
+    end
+    final_env = field
+
+    if not final_env then
+      return {}, 0
+    end
+  end
+
+  local keys = {}
+  ---@private
+  local function insert_keys(obj)
+    for k,_ in pairs(obj) do
+      if type(k) == "string" and string.sub(k,1,string.len(match_part)) == match_part then
+        table.insert(keys,k)
+      end
+    end
+  end
+
+  if type(final_env) == "table" then
+    insert_keys(final_env)
+  end
+  local mt = getmetatable(final_env)
+  if mt and type(mt.__index) == "table" then
+    insert_keys(mt.__index)
+  end
+
+  table.sort(keys)
+
+  return keys, #prefix_match_pat
+end
+
+vim._expand_pat_get_parts = function(lua_string)
+  local parts = {}
+
+  local accumulator, search_index = '', 1
+  local in_brackets, bracket_end = false, -1
+  local string_char = nil
+  for idx = 1, #lua_string do
+    local s = lua_string:sub(idx, idx)
+
+    if not in_brackets and (s == "." or s == ":") then
+      table.insert(parts, accumulator)
+      accumulator = ''
+
+      search_index = idx + 1
+    elseif s == "[" then
+      in_brackets = true
+
+      table.insert(parts, accumulator)
+      accumulator = ''
+
+      search_index = idx + 1
+    elseif in_brackets then
+      if idx == bracket_end then
+        in_brackets = false
+        search_index = idx + 1
+
+        if string_char == "VAR" then
+          table.insert(parts, { accumulator })
+          accumulator = ''
+
+          string_char = nil
+        end
+      elseif not string_char then
+        bracket_end = string.find(lua_string, ']', idx, true)
+
+        if s == '"' or s == "'" then
+          string_char = s
+        elseif s ~= ' ' then
+          string_char = "VAR"
+          accumulator = s
+        end
+      elseif string_char then
+        if string_char ~= s then
+          accumulator = accumulator .. s
+        else
+          table.insert(parts, accumulator)
+          accumulator = ''
+
+          string_char = nil
+        end
+      end
+    else
+      accumulator = accumulator .. s
+    end
+  end
+
+  parts = vim.tbl_filter(function(val) return #val > 0 end, parts)
+
+  return parts, search_index
+end
+
+---Prints given arguments in human-readable format.
+---Example:
+---<pre>
+---  -- Print highlight group Normal and store it's contents in a variable.
+---  local hl_normal = vim.pretty_print(vim.api.nvim_get_hl_by_name("Normal", true))
+---</pre>
+---@see |vim.inspect()|
+---@return given arguments.
+function vim.pretty_print(...)
+  local objects = {}
+  for i = 1, select('#', ...) do
+    local v = select(i, ...)
+    table.insert(objects, vim.inspect(v))
+  end
+
+  print(table.concat(objects, '    '))
+  return ...
+end
+
+
+require('vim._meta')
+
+return vim
-- 
cgit 


From 80e6f81862d943b2d31639a0e437b6abdff3373c Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 21:16:21 +0800
Subject: docs(lua): reference runtime/lua/vim/_editor.lua

---
 runtime/lua/vim/_editor.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 5f3329ef42..ddd1147468 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -5,7 +5,7 @@
 --       `inspect` and `lpeg` modules.
 --    2. runtime/lua/vim/shared.lua: Code shared between Nvim and tests.
 --       (This will go away if we migrate to nvim as the test-runner.)
---    3. src/nvim/lua/: Compiled-into Nvim itself.
+--    3. runtime/lua/vim/_editor.lua: Compiled-into Nvim itself.
 --
 -- Guideline: "If in doubt, put it in the runtime".
 --
-- 
cgit 


From f39a12d629500bdbacb389ed593adac34d058fcb Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Sun, 6 Mar 2022 13:13:10 +0100
Subject: refactor(lua): make vim submodule lazy loading declarative

This will allow us to also use the same logic for lua threads and
processes, later.
---
 runtime/lua/vim/_editor.lua | 52 +++++++++++++--------------------------------
 1 file changed, 15 insertions(+), 37 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index ddd1147468..2251aca004 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -3,9 +3,11 @@
 -- Lua code lives in one of three places:
 --    1. runtime/lua/vim/ (the runtime): For "nice to have" features, e.g. the
 --       `inspect` and `lpeg` modules.
---    2. runtime/lua/vim/shared.lua: Code shared between Nvim and tests.
---       (This will go away if we migrate to nvim as the test-runner.)
---    3. runtime/lua/vim/_editor.lua: Compiled-into Nvim itself.
+--    2. runtime/lua/vim/shared.lua: pure lua functions which always
+--       are available. Used in the test runner, as well as worker threads
+--       and processes launched from Nvim.
+--    3. runtime/lua/vim/_editor.lua: Code which directly interacts with
+--       the Nvim editor state. Only available in the main thread.
 --
 -- Guideline: "If in doubt, put it in the runtime".
 --
@@ -35,43 +37,19 @@
 --    - https://github.com/howl-editor/howl/tree/master/lib/howl/util
 
 local vim = assert(vim)
-assert(vim.inspect)
 
 -- These are for loading runtime modules lazily since they aren't available in
 -- the nvim binary as specified in executor.c
-setmetatable(vim, {
-  __index = function(t, key)
-    if key == 'treesitter' then
-      t.treesitter = require('vim.treesitter')
-      return t.treesitter
-    elseif key == 'filetype' then
-      t.filetype = require('vim.filetype')
-      return t.filetype
-    elseif key == 'F' then
-      t.F = require('vim.F')
-      return t.F
-    elseif require('vim.uri')[key] ~= nil then
-      -- Expose all `vim.uri` functions on the `vim` module.
-      t[key] = require('vim.uri')[key]
-      return t[key]
-    elseif key == 'lsp' then
-      t.lsp = require('vim.lsp')
-      return t.lsp
-    elseif key == 'highlight' then
-      t.highlight = require('vim.highlight')
-      return t.highlight
-    elseif key == 'diagnostic' then
-      t.diagnostic = require('vim.diagnostic')
-      return t.diagnostic
-    elseif key == 'keymap' then
-      t.keymap = require('vim.keymap')
-      return t.keymap
-    elseif key == 'ui' then
-      t.ui = require('vim.ui')
-      return t.ui
-    end
-  end
-})
+for k,v in pairs {
+  treesitter=true;
+  filetype = true;
+  F=true;
+  lsp=true;
+  highlight=true;
+  diagnostic=true;
+  keymap=true;
+  ui=true;
+} do vim._submodules[k] = v end
 
 vim.log = {
   levels = {
-- 
cgit 


From 5ed60804fe69e97a699ca64422f4f7f4cc20f3da Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Wed, 9 Mar 2022 14:26:01 +0100
Subject: feat(lua): handle lazy submodules in `:lua vim.` wildmenu completion

---
 runtime/lua/vim/_editor.lua | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 2251aca004..3136e36043 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -519,6 +519,8 @@ function vim._expand_pat(pat, env)
       local mt = getmetatable(final_env)
       if mt and type(mt.__index) == "table" then
         field = rawget(mt.__index, key)
+      elseif final_env == vim and vim._submodules[key] then
+        field = vim[key]
       end
     end
     final_env = field
@@ -545,6 +547,9 @@ function vim._expand_pat(pat, env)
   if mt and type(mt.__index) == "table" then
     insert_keys(mt.__index)
   end
+  if final_env == vim then
+    insert_keys(vim._submodules)
+  end
 
   table.sort(keys)
 
-- 
cgit 


From 5862176764c7a86d5fdd2685122810e14a3d5b02 Mon Sep 17 00:00:00 2001
From: Charlie Groves <charlie.groves@gmail.com>
Date: Wed, 16 Feb 2022 17:11:50 -0500
Subject: feat(remote): add basic --remote support

This is starting from @geekodour's work at
https://github.com/neovim/neovim/pull/8326
---
 runtime/lua/vim/_editor.lua | 72 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 3136e36043..5f3d66e108 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -636,6 +636,78 @@ function vim.pretty_print(...)
   return ...
 end
 
+local function __rpcrequest(...)
+  return vim.api.nvim_call_function("rpcrequest", {...})
+end
+
+function vim._cs_remote(rcid, args)
+
+  local f_silent = false
+  local f_wait = false
+  local f_tab = false
+  local should_exit = true
+  local command = 'edit '
+
+  local subcmd = string.sub(args[1],10)
+
+  if subcmd == '' then
+    -- no flags to set
+  elseif subcmd == 'tab' then
+    f_tab = true
+  elseif subcmd == 'silent' then
+    f_silent = true
+  elseif subcmd == 'wait' then
+    f_wait = true
+  elseif subcmd == 'wait-silent' then
+    f_wait = true
+    f_silent = true
+  elseif subcmd == 'tab-wait' then
+    f_tab = true
+    f_wait = true
+  elseif subcmd == 'tab-silent' then
+    f_tab = true
+    f_silent = true
+  elseif subcmd == 'tab-wait-silent' then
+    f_tab = true
+    f_wait = true
+    f_silent = true
+  elseif subcmd == 'send' then
+    __rpcrequest(rcid, 'nvim_input', args[2])
+    return { should_exit = should_exit, tabbed = f_tab, files = 0 }
+    -- should we show warning if --server doesn't exist in --send and --expr?
+  elseif subcmd == 'expr' then
+    local res = __rpcrequest(rcid, 'vim_eval', args[2])
+    print(res)
+    return { should_exit = should_exit, tabbed = f_tab, files = 0 }
+  else
+    print('--remote subcommand not found')
+  end
+
+  table.remove(args,1)
+
+  if not f_silent and rcid == 0 then
+    print('Remote server does not exist.')
+  end
+
+  if f_silent and rcid == 0 then
+    print('Remote server does not exist. starting new server')
+    should_exit = false
+  end
+
+  if f_tab then command = 'tabedit ' end
+
+  if rcid ~= 0 then
+    for _, key in ipairs(args) do
+      __rpcrequest(rcid, 'nvim_command', command .. key)
+    end
+  end
+
+  return {
+    should_exit = should_exit,
+    tabbed = f_tab,
+    files = table.getn(args)
+  }
+end
 
 require('vim._meta')
 
-- 
cgit 


From 039e94f491d2f8576cbef1aeacd5ea1f7bc0982a Mon Sep 17 00:00:00 2001
From: Charlie Groves <charlie.groves@gmail.com>
Date: Thu, 24 Feb 2022 10:47:41 -0500
Subject: test(remote): add tests for --remote

This also fixes a fair number of issues found in running the tests
---
 runtime/lua/vim/_editor.lua | 57 +++++++++++++++++++++------------------------
 1 file changed, 26 insertions(+), 31 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 5f3d66e108..869a2706ac 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -636,17 +636,10 @@ function vim.pretty_print(...)
   return ...
 end
 
-local function __rpcrequest(...)
-  return vim.api.nvim_call_function("rpcrequest", {...})
-end
-
 function vim._cs_remote(rcid, args)
-
   local f_silent = false
   local f_wait = false
   local f_tab = false
-  local should_exit = true
-  local command = 'edit '
 
   local subcmd = string.sub(args[1],10)
 
@@ -672,40 +665,42 @@ function vim._cs_remote(rcid, args)
     f_wait = true
     f_silent = true
   elseif subcmd == 'send' then
-    __rpcrequest(rcid, 'nvim_input', args[2])
-    return { should_exit = should_exit, tabbed = f_tab, files = 0 }
-    -- should we show warning if --server doesn't exist in --send and --expr?
+    if rcid == 0 then
+      vim.cmd('echoerr "E247: Remote server does not exist. Send failed."')
+      return
+    end
+    vim.fn.rpcrequest(rcid, 'nvim_input', args[2])
+    return { should_exit = true, tabbed = false }
   elseif subcmd == 'expr' then
-    local res = __rpcrequest(rcid, 'vim_eval', args[2])
-    print(res)
-    return { should_exit = should_exit, tabbed = f_tab, files = 0 }
+    if rcid == 0 then
+      vim.cmd('echoerr "E247: Remote server does not exist. Send expression failed."')
+      return
+    end
+    vim.fn.rpcrequest(rcid, 'nvim_eval', args[2])
+    return { should_exit = true, tabbed = false }
   else
-    print('--remote subcommand not found')
+    vim.cmd('echoerr "Unknown option argument: ' .. args[1] .. '"')
+    return
   end
 
-  table.remove(args,1)
-
-  if not f_silent and rcid == 0 then
-    print('Remote server does not exist.')
-  end
-
-  if f_silent and rcid == 0 then
-    print('Remote server does not exist. starting new server')
+  if rcid == 0 then
+    if not f_silent then
+      vim.cmd('echohl WarningMsg | echomsg "E247: Remote server does not exist. Editing locally" | echohl None')
+    end
     should_exit = false
-  end
-
-  if f_tab then command = 'tabedit ' end
-
-  if rcid ~= 0 then
-    for _, key in ipairs(args) do
-      __rpcrequest(rcid, 'nvim_command', command .. key)
+  else
+    local command = {}
+    if f_tab then table.insert(command, 'tab') end
+    table.insert(command, 'drop')
+    for i = 2, #args do
+      table.insert(command, vim.fn.fnameescape(args[i]))
     end
+    vim.fn.rpcrequest(rcid, 'nvim_command', table.concat(command, ' '))
   end
 
   return {
-    should_exit = should_exit,
+    should_exit = rcid ~= 0,
     tabbed = f_tab,
-    files = table.getn(args)
   }
 end
 
-- 
cgit 


From 29c36322857b37263b07eb1301d71ccd8a2ae044 Mon Sep 17 00:00:00 2001
From: Charlie Groves <charlie.groves@gmail.com>
Date: Thu, 3 Mar 2022 16:33:27 -0500
Subject: fix(remote): report on missing wait commands, typecheck lua results

Clean up lint errors, too
---
 runtime/lua/vim/_editor.lua | 33 ++++++++-------------------------
 1 file changed, 8 insertions(+), 25 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 869a2706ac..030c3b40e8 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -638,56 +638,39 @@ end
 
 function vim._cs_remote(rcid, args)
   local f_silent = false
-  local f_wait = false
   local f_tab = false
 
   local subcmd = string.sub(args[1],10)
 
-  if subcmd == '' then
-    -- no flags to set
-  elseif subcmd == 'tab' then
+  if subcmd == 'tab' then
     f_tab = true
   elseif subcmd == 'silent' then
     f_silent = true
-  elseif subcmd == 'wait' then
-    f_wait = true
-  elseif subcmd == 'wait-silent' then
-    f_wait = true
-    f_silent = true
-  elseif subcmd == 'tab-wait' then
-    f_tab = true
-    f_wait = true
+  elseif subcmd == 'wait' or subcmd == 'wait-silent' or subcmd == 'tab-wait' or subcmd == 'tab-wait-silent' then
+    return { errmsg = 'E5600: Wait commands not yet implemented in nvim' }
   elseif subcmd == 'tab-silent' then
     f_tab = true
     f_silent = true
-  elseif subcmd == 'tab-wait-silent' then
-    f_tab = true
-    f_wait = true
-    f_silent = true
   elseif subcmd == 'send' then
     if rcid == 0 then
-      vim.cmd('echoerr "E247: Remote server does not exist. Send failed."')
-      return
+      return { errmsg = 'E247: Remote server does not exist. Send failed.' }
     end
     vim.fn.rpcrequest(rcid, 'nvim_input', args[2])
     return { should_exit = true, tabbed = false }
   elseif subcmd == 'expr' then
     if rcid == 0 then
-      vim.cmd('echoerr "E247: Remote server does not exist. Send expression failed."')
-      return
+      return { errmsg = 'E247: Remote server does not exist. Send expression failed.' }
     end
-    vim.fn.rpcrequest(rcid, 'nvim_eval', args[2])
+    print(vim.fn.rpcrequest(rcid, 'nvim_eval', args[2]))
     return { should_exit = true, tabbed = false }
-  else
-    vim.cmd('echoerr "Unknown option argument: ' .. args[1] .. '"')
-    return
+  elseif subcmd ~= '' then
+    return { errmsg='Unknown option argument: ' .. args[1] }
   end
 
   if rcid == 0 then
     if not f_silent then
       vim.cmd('echohl WarningMsg | echomsg "E247: Remote server does not exist. Editing locally" | echohl None')
     end
-    should_exit = false
   else
     local command = {}
     if f_tab then table.insert(command, 'tab') end
-- 
cgit 


From 1dbf8675c71dc500ae7502085161cd56e311ccf6 Mon Sep 17 00:00:00 2001
From: Charlie Groves <charlie.groves@gmail.com>
Date: Fri, 11 Mar 2022 11:16:34 -0500
Subject: fix(remote): respect silent in error reporting

---
 runtime/lua/vim/_editor.lua | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 030c3b40e8..a0c60a7dcf 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -636,12 +636,24 @@ function vim.pretty_print(...)
   return ...
 end
 
-function vim._cs_remote(rcid, args)
+function vim._cs_remote(rcid, server_addr, connect_error, args)
+  local function connection_failure_errmsg(consequence)
+    local explanation
+    if server_addr == '' then
+      explanation = "No server specified with --server"
+    else
+      explanation = "Failed to connect to '" .. server_addr .. "'"
+      if connect_error ~= "" then
+        explanation = explanation .. ": " .. connect_error
+      end
+    end
+    return "E247: " .. explanation .. ". " .. consequence
+  end
+
   local f_silent = false
   local f_tab = false
 
   local subcmd = string.sub(args[1],10)
-
   if subcmd == 'tab' then
     f_tab = true
   elseif subcmd == 'silent' then
@@ -653,13 +665,13 @@ function vim._cs_remote(rcid, args)
     f_silent = true
   elseif subcmd == 'send' then
     if rcid == 0 then
-      return { errmsg = 'E247: Remote server does not exist. Send failed.' }
+      return { errmsg = connection_failure_errmsg('Send failed.') }
     end
     vim.fn.rpcrequest(rcid, 'nvim_input', args[2])
     return { should_exit = true, tabbed = false }
   elseif subcmd == 'expr' then
     if rcid == 0 then
-      return { errmsg = 'E247: Remote server does not exist. Send expression failed.' }
+      return { errmsg = connection_failure_errmsg('Send expression failed.') }
     end
     print(vim.fn.rpcrequest(rcid, 'nvim_eval', args[2]))
     return { should_exit = true, tabbed = false }
@@ -669,7 +681,7 @@ function vim._cs_remote(rcid, args)
 
   if rcid == 0 then
     if not f_silent then
-      vim.cmd('echohl WarningMsg | echomsg "E247: Remote server does not exist. Editing locally" | echohl None')
+      vim.notify(connection_failure_errmsg("Editing locally"), vim.log.levels.WARN)
     end
   else
     local command = {}
-- 
cgit 


From 9b1e1fbc9f795921afd25ba38be5c79dec8b04d2 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: fix(paste): use getcmdtype() to determine whether in cmdline mode

---
 runtime/lua/vim/_editor.lua | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index a0c60a7dcf..8000730795 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -156,21 +156,21 @@ do
   ---                - 3: ends the paste (exactly once)
   ---@returns false if client should cancel the paste.
   function vim.paste(lines, phase)
-    local call = vim.api.nvim_call_function
     local now = vim.loop.now()
-    local mode = call('mode', {}):sub(1,1)
+    local mode = vim.api.nvim_get_mode().mode
+    local is_cmdline = vim.fn.getcmdtype() ~= ''
     if phase < 2 then  -- Reset flags.
       tdots, tick, got_line1 = now, 0, false
-    elseif mode ~= 'c' then
+    elseif not is_cmdline then
       vim.api.nvim_command('undojoin')
     end
-    if mode == 'c' and not got_line1 then  -- cmdline-mode: paste only 1 line.
+    if is_cmdline and not got_line1 then  -- cmdline-mode: paste only 1 line.
       got_line1 = (#lines > 1)
       vim.api.nvim_set_option('paste', true)  -- For nvim_input().
       local line1 = lines[1]:gsub('<', '<lt>'):gsub('[\r\n\012\027]', ' ')  -- Scrub.
       vim.api.nvim_input(line1)
       vim.api.nvim_set_option('paste', false)
-    elseif mode ~= 'c' then
+    elseif not is_cmdline then
       if phase < 2 and mode:find('^[vV\22sS\19]') then
         vim.api.nvim_command([[exe "normal! \<Del>"]])
         vim.api.nvim_put(lines, 'c', false, true)
@@ -178,7 +178,7 @@ do
         vim.api.nvim_put(lines, 'c', true, true)
         -- XXX: Normal-mode: workaround bad cursor-placement after first chunk.
         vim.api.nvim_command('normal! a')
-      elseif phase < 2 and mode == 'R' then
+      elseif phase < 2 and mode:find('^R') then
         local nchars = 0
         for _, line in ipairs(lines) do
             nchars = nchars + line:len()
-- 
cgit 


From 2601e0873ff50ed804487dff00bd27e233709beb Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: fix(paste): don't move cursor past the end of pasted text in Normal
 mode

---
 runtime/lua/vim/_editor.lua | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 8000730795..8e49b51cec 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -171,27 +171,34 @@ do
       vim.api.nvim_input(line1)
       vim.api.nvim_set_option('paste', false)
     elseif not is_cmdline then
-      if phase < 2 and mode:find('^[vV\22sS\19]') then
-        vim.api.nvim_command([[exe "normal! \<Del>"]])
+      if mode:find('^i') or mode:find('^n?t') then  -- Insert mode or Terminal buffer
         vim.api.nvim_put(lines, 'c', false, true)
-      elseif phase < 2 and not mode:find('^[iRt]') then
-        vim.api.nvim_put(lines, 'c', true, true)
-        -- XXX: Normal-mode: workaround bad cursor-placement after first chunk.
-        vim.api.nvim_command('normal! a')
-      elseif phase < 2 and mode:find('^R') then
+      elseif phase < 2 and mode:find('^R') and not mode:find('^Rv') then  -- Replace mode
+        -- TODO: implement Replace mode streamed pasting
+        -- TODO: support Virtual Replace mode
         local nchars = 0
         for _, line in ipairs(lines) do
-            nchars = nchars + line:len()
+          nchars = nchars + line:len()
         end
         local row, col = unpack(vim.api.nvim_win_get_cursor(0))
         local bufline = vim.api.nvim_buf_get_lines(0, row-1, row, true)[1]
         local firstline = lines[1]
         firstline = bufline:sub(1, col)..firstline
         lines[1] = firstline
+        -- FIXME: #lines can be 0
         lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
         vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
-      else
-        vim.api.nvim_put(lines, 'c', false, true)
+      elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
+        if mode:find('^n') then  -- Normal mode
+          vim.api.nvim_put(lines, 'c', true, false)
+        else  -- Visual or Select mode
+          vim.api.nvim_command([[exe "normal! \<Del>"]])
+          vim.api.nvim_put(lines, 'c', false, false)
+        end
+        -- put cursor at the end of the text instead of one character after it
+        vim.fn.setpos('.', vim.fn.getpos("']"))
+      else  -- Don't know what to do in other modes
+        return false
       end
     end
     if phase ~= -1 and (now - tdots >= 100) then
-- 
cgit 


From bfb77544425b7cca372cb87f00ef6b6e87c5f6d5 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: fix(paste): deal with eol and eof in Visual mode

---
 runtime/lua/vim/_editor.lua | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 8e49b51cec..6b1725c9ff 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -192,8 +192,19 @@ do
         if mode:find('^n') then  -- Normal mode
           vim.api.nvim_put(lines, 'c', true, false)
         else  -- Visual or Select mode
-          vim.api.nvim_command([[exe "normal! \<Del>"]])
-          vim.api.nvim_put(lines, 'c', false, false)
+          vim.api.nvim_command([[exe "silent normal! \<Del>"]])
+          local del_start = vim.fn.getpos("'[")
+          local cursor_pos = vim.fn.getpos('.')
+          if mode:find('^[VS]') then  -- linewise
+            if cursor_pos[2] < del_start[2] then  -- replacing lines at eof
+              -- create a new line
+              vim.api.nvim_put({''}, 'l', true, true)
+            end
+            vim.api.nvim_put(lines, 'c', false, false)
+          else
+            -- paste after cursor when replacing text at eol, otherwise paste before cursor
+            vim.api.nvim_put(lines, 'c', cursor_pos[3] < del_start[3], false)
+          end
         end
         -- put cursor at the end of the text instead of one character after it
         vim.fn.setpos('.', vim.fn.getpos("']"))
-- 
cgit 


From 21ba2d81a848e7b85739fc3e9aa2eb0b5e35c879 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: refactor(paste): do not print dots in cmdline mode

---
 runtime/lua/vim/_editor.lua | 100 +++++++++++++++++++++++---------------------
 1 file changed, 52 insertions(+), 48 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 6b1725c9ff..a7f8f0e7b6 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -157,60 +157,64 @@ do
   ---@returns false if client should cancel the paste.
   function vim.paste(lines, phase)
     local now = vim.loop.now()
-    local mode = vim.api.nvim_get_mode().mode
-    local is_cmdline = vim.fn.getcmdtype() ~= ''
-    if phase < 2 then  -- Reset flags.
+    local is_first_chunk = phase < 2
+    if is_first_chunk then  -- Reset flags.
       tdots, tick, got_line1 = now, 0, false
-    elseif not is_cmdline then
+    end
+    -- Note: mode doesn't always start with "c" in cmdline mode, so use getcmdtype() instead.
+    if vim.fn.getcmdtype() ~= '' then  -- cmdline-mode: paste only 1 line.
+      if not got_line1 then
+        got_line1 = (#lines > 1)
+        vim.api.nvim_set_option('paste', true)  -- For nvim_input().
+        local line1 = lines[1]:gsub('<', '<lt>'):gsub('[\r\n\012\027]', ' ')  -- Scrub.
+        vim.api.nvim_input(line1)
+        vim.api.nvim_set_option('paste', false)
+      end
+      return true
+    end
+    local mode = vim.api.nvim_get_mode().mode
+    if not is_first_chunk then
       vim.api.nvim_command('undojoin')
     end
-    if is_cmdline and not got_line1 then  -- cmdline-mode: paste only 1 line.
-      got_line1 = (#lines > 1)
-      vim.api.nvim_set_option('paste', true)  -- For nvim_input().
-      local line1 = lines[1]:gsub('<', '<lt>'):gsub('[\r\n\012\027]', ' ')  -- Scrub.
-      vim.api.nvim_input(line1)
-      vim.api.nvim_set_option('paste', false)
-    elseif not is_cmdline then
-      if mode:find('^i') or mode:find('^n?t') then  -- Insert mode or Terminal buffer
-        vim.api.nvim_put(lines, 'c', false, true)
-      elseif phase < 2 and mode:find('^R') and not mode:find('^Rv') then  -- Replace mode
-        -- TODO: implement Replace mode streamed pasting
-        -- TODO: support Virtual Replace mode
-        local nchars = 0
-        for _, line in ipairs(lines) do
-          nchars = nchars + line:len()
-        end
-        local row, col = unpack(vim.api.nvim_win_get_cursor(0))
-        local bufline = vim.api.nvim_buf_get_lines(0, row-1, row, true)[1]
-        local firstline = lines[1]
-        firstline = bufline:sub(1, col)..firstline
-        lines[1] = firstline
-        -- FIXME: #lines can be 0
-        lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
-        vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
-      elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
-        if mode:find('^n') then  -- Normal mode
-          vim.api.nvim_put(lines, 'c', true, false)
-        else  -- Visual or Select mode
-          vim.api.nvim_command([[exe "silent normal! \<Del>"]])
-          local del_start = vim.fn.getpos("'[")
-          local cursor_pos = vim.fn.getpos('.')
-          if mode:find('^[VS]') then  -- linewise
-            if cursor_pos[2] < del_start[2] then  -- replacing lines at eof
-              -- create a new line
-              vim.api.nvim_put({''}, 'l', true, true)
-            end
-            vim.api.nvim_put(lines, 'c', false, false)
-          else
-            -- paste after cursor when replacing text at eol, otherwise paste before cursor
-            vim.api.nvim_put(lines, 'c', cursor_pos[3] < del_start[3], false)
+    if mode:find('^i') or mode:find('^n?t') then  -- Insert mode or Terminal buffer
+      vim.api.nvim_put(lines, 'c', false, true)
+    elseif phase < 2 and mode:find('^R') and not mode:find('^Rv') then  -- Replace mode
+      -- TODO: implement Replace mode streamed pasting
+      -- TODO: support Virtual Replace mode
+      local nchars = 0
+      for _, line in ipairs(lines) do
+        nchars = nchars + line:len()
+      end
+      local row, col = unpack(vim.api.nvim_win_get_cursor(0))
+      local bufline = vim.api.nvim_buf_get_lines(0, row-1, row, true)[1]
+      local firstline = lines[1]
+      firstline = bufline:sub(1, col)..firstline
+      lines[1] = firstline
+      -- FIXME: #lines can be 0
+      lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
+      vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
+    elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
+      if mode:find('^n') then  -- Normal mode
+        vim.api.nvim_put(lines, 'c', true, false)
+      else  -- Visual or Select mode
+        vim.api.nvim_command([[exe "silent normal! \<Del>"]])
+        local del_start = vim.fn.getpos("'[")
+        local cursor_pos = vim.fn.getpos('.')
+        if mode:find('^[VS]') then  -- linewise
+          if cursor_pos[2] < del_start[2] then  -- replacing lines at eof
+            -- create a new line
+            vim.api.nvim_put({''}, 'l', true, true)
           end
+          vim.api.nvim_put(lines, 'c', false, false)
+        else
+          -- paste after cursor when replacing text at eol, otherwise paste before cursor
+          vim.api.nvim_put(lines, 'c', cursor_pos[3] < del_start[3], false)
         end
-        -- put cursor at the end of the text instead of one character after it
-        vim.fn.setpos('.', vim.fn.getpos("']"))
-      else  -- Don't know what to do in other modes
-        return false
       end
+      -- put cursor at the end of the text instead of one character after it
+      vim.fn.setpos('.', vim.fn.getpos("']"))
+    else  -- Don't know what to do in other modes
+      return false
     end
     if phase ~= -1 and (now - tdots >= 100) then
       local dots = ('.'):rep(tick % 4)
-- 
cgit 


From fcc6f66cf2a67cf85e72727a08e19d0f800badb9 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: fix(paste): avoid edges cases caused by empty chunk

---
 runtime/lua/vim/_editor.lua | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index a7f8f0e7b6..42adda6e7f 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -128,7 +128,7 @@ local function inspect(object, options)  -- luacheck: no unused
 end
 
 do
-  local tdots, tick, got_line1 = 0, 0, false
+  local tdots, tick, got_line1, undo_started = 0, 0, false, false
 
   --- Paste handler, invoked by |nvim_paste()| when a conforming UI
   --- (such as the |TUI|) pastes text into the editor.
@@ -158,8 +158,17 @@ do
   function vim.paste(lines, phase)
     local now = vim.loop.now()
     local is_first_chunk = phase < 2
+    local is_last_chunk = phase == -1 or phase == 3
     if is_first_chunk then  -- Reset flags.
-      tdots, tick, got_line1 = now, 0, false
+      tdots, tick, got_line1, undo_started = now, 0, false, false
+    end
+    if #lines == 0 then
+      lines = {''}
+    end
+    if #lines == 1 and lines[1] == '' and not is_last_chunk then
+      -- An empty chunk can cause some edge cases in streamed pasting,
+      -- so don't do anything unless it is the last chunk.
+      return true
     end
     -- Note: mode doesn't always start with "c" in cmdline mode, so use getcmdtype() instead.
     if vim.fn.getcmdtype() ~= '' then  -- cmdline-mode: paste only 1 line.
@@ -173,7 +182,7 @@ do
       return true
     end
     local mode = vim.api.nvim_get_mode().mode
-    if not is_first_chunk then
+    if undo_started then
       vim.api.nvim_command('undojoin')
     end
     if mode:find('^i') or mode:find('^n?t') then  -- Insert mode or Terminal buffer
@@ -190,7 +199,6 @@ do
       local firstline = lines[1]
       firstline = bufline:sub(1, col)..firstline
       lines[1] = firstline
-      -- FIXME: #lines can be 0
       lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
       vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
     elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
@@ -216,6 +224,7 @@ do
     else  -- Don't know what to do in other modes
       return false
     end
+    undo_started = true
     if phase ~= -1 and (now - tdots >= 100) then
       local dots = ('.'):rep(tick % 4)
       tdots = now
@@ -224,7 +233,7 @@ do
       -- message when there are zero dots.
       vim.api.nvim_command(('echo "%s"'):format(dots))
     end
-    if phase == -1 or phase == 3 then
+    if is_last_chunk then
       vim.api.nvim_command('redraw'..(tick > 1 and '|echo ""' or ''))
     end
     return true  -- Paste will not continue if not returning `true`.
-- 
cgit 


From a6eafc77ceaf2d7036aed89361b6556f46131b17 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 6 Mar 2022 06:56:24 +0800
Subject: fix(paste): deal with trailing new line in chunk

---
 runtime/lua/vim/_editor.lua | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 42adda6e7f..26b9693189 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -128,7 +128,7 @@ local function inspect(object, options)  -- luacheck: no unused
 end
 
 do
-  local tdots, tick, got_line1, undo_started = 0, 0, false, false
+  local tdots, tick, got_line1, undo_started, trailing_nl = 0, 0, false, false, false
 
   --- Paste handler, invoked by |nvim_paste()| when a conforming UI
   --- (such as the |TUI|) pastes text into the editor.
@@ -160,7 +160,7 @@ do
     local is_first_chunk = phase < 2
     local is_last_chunk = phase == -1 or phase == 3
     if is_first_chunk then  -- Reset flags.
-      tdots, tick, got_line1, undo_started = now, 0, false, false
+      tdots, tick, got_line1, undo_started, trailing_nl = now, 0, false, false, false
     end
     if #lines == 0 then
       lines = {''}
@@ -203,7 +203,10 @@ do
       vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
     elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
       if mode:find('^n') then  -- Normal mode
-        vim.api.nvim_put(lines, 'c', true, false)
+        -- When there was a trailing new line in the previous chunk,
+        -- the cursor is on the first character of the next line,
+        -- so paste before the cursor instead of after it.
+        vim.api.nvim_put(lines, 'c', not trailing_nl, false)
       else  -- Visual or Select mode
         vim.api.nvim_command([[exe "silent normal! \<Del>"]])
         local del_start = vim.fn.getpos("'[")
@@ -221,6 +224,7 @@ do
       end
       -- put cursor at the end of the text instead of one character after it
       vim.fn.setpos('.', vim.fn.getpos("']"))
+      trailing_nl = lines[#lines] == ''
     else  -- Don't know what to do in other modes
       return false
     end
-- 
cgit 


From e263afc0e972d11d3b9b663c3ac0b5575c4deb88 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 15 Mar 2022 06:04:50 +0800
Subject: fix(paste): escape control characters in Cmdline mode

---
 runtime/lua/vim/_editor.lua | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 26b9693189..d4db4850bd 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -175,7 +175,8 @@ do
       if not got_line1 then
         got_line1 = (#lines > 1)
         vim.api.nvim_set_option('paste', true)  -- For nvim_input().
-        local line1 = lines[1]:gsub('<', '<lt>'):gsub('[\r\n\012\027]', ' ')  -- Scrub.
+        -- Escape "<" and control characters
+        local line1 = lines[1]:gsub('<', '<lt>'):gsub('(%c)', '\022%1')
         vim.api.nvim_input(line1)
         vim.api.nvim_set_option('paste', false)
       end
-- 
cgit 


From 813ecdac795405565aab5cb61cb83b9ca1581b60 Mon Sep 17 00:00:00 2001
From: Eden Zhang <53964412+VelocityDv@users.noreply.github.com>
Date: Sun, 17 Apr 2022 12:11:53 +1200
Subject: fix(paste): ignore mappings in Cmdline mode (#18114)

---
 runtime/lua/vim/_editor.lua | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index d4db4850bd..8e372b806c 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -174,11 +174,11 @@ do
     if vim.fn.getcmdtype() ~= '' then  -- cmdline-mode: paste only 1 line.
       if not got_line1 then
         got_line1 = (#lines > 1)
-        vim.api.nvim_set_option('paste', true)  -- For nvim_input().
-        -- Escape "<" and control characters
-        local line1 = lines[1]:gsub('<', '<lt>'):gsub('(%c)', '\022%1')
-        vim.api.nvim_input(line1)
-        vim.api.nvim_set_option('paste', false)
+        -- Escape control characters
+        local line1 = lines[1]:gsub('(%c)', '\022%1')
+        -- nvim_input() is affected by mappings,
+        -- so use nvim_feedkeys() with "n" flag to ignore mappings.
+        vim.api.nvim_feedkeys(line1, 'n', true)
       end
       return true
     end
-- 
cgit 


From 73741e94867a8dedabcbd356e1e929f198c51905 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Tue, 3 May 2022 15:42:41 +0200
Subject: feat(lua): vim.deprecate() #18320

This is primarily intended to act as documentation for the developer so
they know exactly when and what to remove. This will help prevent the
situation of deprecated code lingering for far too long as developers
don't have to worry if a function is safe to remove.
---
 runtime/lua/vim/_editor.lua | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 8e372b806c..62a7b3df13 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -735,6 +735,22 @@ function vim._cs_remote(rcid, server_addr, connect_error, args)
   }
 end
 
+--- Display a deprecation notification to the user.
+---
+---@param name        string     Deprecated function.
+---@param alternative string|nil Preferred alternative function.
+---@param version     string     Version in which the deprecated function will
+---                              be removed.
+---@param plugin      string|nil Plugin name that the function will be removed
+---                              from. Defaults to "Nvim".
+function vim.deprecate(name, alternative, version, plugin)
+    local message = name .. ' is deprecated'
+    plugin = plugin or "Nvim"
+    message = alternative and (message .. ', use ' .. alternative .. ' instead.') or message
+    message = message .. ' See :h deprecated\nThis function will be removed in ' .. plugin .. ' version ' .. version
+    vim.notify_once(message, vim.log.levels.WARN)
+end
+
 require('vim._meta')
 
 return vim
-- 
cgit 


From 70e2c5d10d2574b77c56d0bebeb61527876ff0b1 Mon Sep 17 00:00:00 2001
From: ii14 <59243201+ii14@users.noreply.github.com>
Date: Tue, 3 May 2022 16:49:23 +0200
Subject: feat(lsp): add logging level "OFF" (#18379)

---
 runtime/lua/vim/_editor.lua | 1 +
 1 file changed, 1 insertion(+)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 62a7b3df13..119467de16 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -58,6 +58,7 @@ vim.log = {
     INFO  = 2;
     WARN  = 3;
     ERROR = 4;
+    OFF   = 5;
   }
 }
 
-- 
cgit 


From aefdc6783cb77f09786542c90901a9e7120bea42 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Mon, 9 May 2022 11:23:51 +0200
Subject: chore: format runtime with stylua

---
 runtime/lua/vim/_editor.lua | 214 ++++++++++++++++++++++++--------------------
 1 file changed, 115 insertions(+), 99 deletions(-)

(limited to 'runtime/lua/vim/_editor.lua')

diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 119467de16..9bdbf6d1c7 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -40,26 +40,28 @@ local vim = assert(vim)
 
 -- These are for loading runtime modules lazily since they aren't available in
 -- the nvim binary as specified in executor.c
-for k,v in pairs {
-  treesitter=true;
-  filetype = true;
-  F=true;
-  lsp=true;
-  highlight=true;
-  diagnostic=true;
-  keymap=true;
-  ui=true;
-} do vim._submodules[k] = v end
+for k, v in pairs({
+  treesitter = true,
+  filetype = true,
+  F = true,
+  lsp = true,
+  highlight = true,
+  diagnostic = true,
+  keymap = true,
+  ui = true,
+}) do
+  vim._submodules[k] = v
+end
 
 vim.log = {
   levels = {
-    TRACE = 0;
-    DEBUG = 1;
-    INFO  = 2;
-    WARN  = 3;
-    ERROR = 4;
-    OFF   = 5;
-  }
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    OFF = 5,
+  },
 }
 
 -- Internal-only until comments in #8107 are addressed.
@@ -77,14 +79,14 @@ function vim._os_proc_info(pid)
   if pid == nil or pid <= 0 or type(pid) ~= 'number' then
     error('invalid pid')
   end
-  local cmd = { 'ps', '-p', pid, '-o', 'comm=', }
+  local cmd = { 'ps', '-p', pid, '-o', 'comm=' }
   local err, name = vim._system(cmd)
   if 1 == err and vim.trim(name) == '' then
-    return {}  -- Process not found.
+    return {} -- Process not found.
   elseif 0 ~= err then
-    error('command failed: '..vim.fn.string(cmd))
+    error('command failed: ' .. vim.fn.string(cmd))
   end
-  local _, ppid = vim._system({ 'ps', '-p', pid, '-o', 'ppid=', })
+  local _, ppid = vim._system({ 'ps', '-p', pid, '-o', 'ppid=' })
   -- Remove trailing whitespace.
   name = vim.trim(name):gsub('^.*/', '')
   ppid = tonumber(ppid) or -1
@@ -101,12 +103,12 @@ function vim._os_proc_children(ppid)
   if ppid == nil or ppid <= 0 or type(ppid) ~= 'number' then
     error('invalid ppid')
   end
-  local cmd = { 'pgrep', '-P', ppid, }
+  local cmd = { 'pgrep', '-P', ppid }
   local err, rv = vim._system(cmd)
   if 1 == err and vim.trim(rv) == '' then
-    return {}  -- Process not found.
+    return {} -- Process not found.
   elseif 0 ~= err then
-    error('command failed: '..vim.fn.string(cmd))
+    error('command failed: ' .. vim.fn.string(cmd))
   end
   local children = {}
   for s in rv:gmatch('%S+') do
@@ -124,8 +126,8 @@ end
 ---
 ---@see https://github.com/kikito/inspect.lua
 ---@see https://github.com/mpeterv/vinspect
-local function inspect(object, options)  -- luacheck: no unused
-  error(object, options)  -- Stub for gen_vimdoc.py
+local function inspect(object, options) -- luacheck: no unused
+  error(object, options) -- Stub for gen_vimdoc.py
 end
 
 do
@@ -160,11 +162,11 @@ do
     local now = vim.loop.now()
     local is_first_chunk = phase < 2
     local is_last_chunk = phase == -1 or phase == 3
-    if is_first_chunk then  -- Reset flags.
+    if is_first_chunk then -- Reset flags.
       tdots, tick, got_line1, undo_started, trailing_nl = now, 0, false, false, false
     end
     if #lines == 0 then
-      lines = {''}
+      lines = { '' }
     end
     if #lines == 1 and lines[1] == '' and not is_last_chunk then
       -- An empty chunk can cause some edge cases in streamed pasting,
@@ -172,7 +174,7 @@ do
       return true
     end
     -- Note: mode doesn't always start with "c" in cmdline mode, so use getcmdtype() instead.
-    if vim.fn.getcmdtype() ~= '' then  -- cmdline-mode: paste only 1 line.
+    if vim.fn.getcmdtype() ~= '' then -- cmdline-mode: paste only 1 line.
       if not got_line1 then
         got_line1 = (#lines > 1)
         -- Escape control characters
@@ -187,9 +189,9 @@ do
     if undo_started then
       vim.api.nvim_command('undojoin')
     end
-    if mode:find('^i') or mode:find('^n?t') then  -- Insert mode or Terminal buffer
+    if mode:find('^i') or mode:find('^n?t') then -- Insert mode or Terminal buffer
       vim.api.nvim_put(lines, 'c', false, true)
-    elseif phase < 2 and mode:find('^R') and not mode:find('^Rv') then  -- Replace mode
+    elseif phase < 2 and mode:find('^R') and not mode:find('^Rv') then -- Replace mode
       -- TODO: implement Replace mode streamed pasting
       -- TODO: support Virtual Replace mode
       local nchars = 0
@@ -197,26 +199,26 @@ do
         nchars = nchars + line:len()
       end
       local row, col = unpack(vim.api.nvim_win_get_cursor(0))
-      local bufline = vim.api.nvim_buf_get_lines(0, row-1, row, true)[1]
+      local bufline = vim.api.nvim_buf_get_lines(0, row - 1, row, true)[1]
       local firstline = lines[1]
-      firstline = bufline:sub(1, col)..firstline
+      firstline = bufline:sub(1, col) .. firstline
       lines[1] = firstline
-      lines[#lines] = lines[#lines]..bufline:sub(col + nchars + 1, bufline:len())
-      vim.api.nvim_buf_set_lines(0, row-1, row, false, lines)
-    elseif mode:find('^[nvV\22sS\19]') then  -- Normal or Visual or Select mode
-      if mode:find('^n') then  -- Normal mode
+      lines[#lines] = lines[#lines] .. bufline:sub(col + nchars + 1, bufline:len())
+      vim.api.nvim_buf_set_lines(0, row - 1, row, false, lines)
+    elseif mode:find('^[nvV\22sS\19]') then -- Normal or Visual or Select mode
+      if mode:find('^n') then -- Normal mode
         -- When there was a trailing new line in the previous chunk,
         -- the cursor is on the first character of the next line,
         -- so paste before the cursor instead of after it.
         vim.api.nvim_put(lines, 'c', not trailing_nl, false)
-      else  -- Visual or Select mode
+      else -- Visual or Select mode
         vim.api.nvim_