From cd100963866b2c33a286cbf6aac8e42cd16fd248 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Mon, 29 Oct 2018 19:11:41 +0100
Subject: tree-sitter: initial tree-sitter support

---
 runtime/lua/treesitter_rt.lua | 119 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 runtime/lua/treesitter_rt.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/treesitter_rt.lua b/runtime/lua/treesitter_rt.lua
new file mode 100644
index 0000000000..ba7849abd6
--- /dev/null
+++ b/runtime/lua/treesitter_rt.lua
@@ -0,0 +1,119 @@
+local a = vim.api
+
+if __treesitter_rt_ns == nil then
+    __treesitter_rt_ns = a.nvim_buf_add_highlight(0, 0, "", 0, 0, 0)
+    __treesitter_rt_syn_ns = a.nvim_buf_add_highlight(0, 0, "", 0, 0, 0)
+end
+local my_ns = __treesitter_rt_ns
+local my_syn_ns = __treesitter_rt_syn_ns
+
+local path = '.deps/build/src/treesitter-javascript/src/highlights.json'
+a.nvim_set_var("_ts_path", path)
+obj = a.nvim_eval("json_decode(readfile(g:_ts_path,'b'))")
+
+
+--luadev = require'luadev'
+--i = require'inspect'
+
+
+function parse_tree(tsstate, force)
+  if tsstate.valid and not force then
+    return tsstate.tree
+  end
+  tsstate.tree = tsstate.parser:parse_buf(tsstate.bufnr)
+  tsstate.valid = true
+  return tsstate.tree
+end
+
+function the_cb(tsstate, ev, bufnr, tick, start_row, oldstopline, stop_row)
+  local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
+  -- a bit messy, should we expose edited but not reparsed tree?
+  -- are multiple edits safe in general?
+  local root = tsstate.parser:tree():root()
+  -- TODO: add proper lookup function!
+  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
+  local edit
+  if inode == nil then
+    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
+    tsstate.parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
+  else
+    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
+    local fake_rows = fakeoldstoprow-oldstopline
+    local fakestop = stop_row+fake_rows
+    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
+    tsstate.parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
+  end
+  tsstate.valid = false
+  --luadev.append_buf({i{edit.start_byte,edit.old_end_byte,edit.new_end_byte},
+  --                   i{edit.start_point, edit.old_end_point, edit.new_end_point}})
+end
+
+function attach_buf(tsstate)
+  local function cb(ev, ...)
+    return the_cb(tsstate, ev, ...)
+  end
+  a.nvim_buf_attach(tsstate.bufnr, false, {on_lines=cb})
+end
+
+function create_parser(bufnr)
+  if bufnr == 0 then
+    bufnr = a.nvim_get_current_buf()
+  end
+  local ft = a.nvim_buf_get_option(bufnr, "filetype")
+  local tsstate = {}
+  tsstate.bufnr = bufnr
+  tsstate.parser = vim.ts_parser(ft)
+  parse_tree(tsstate)
+  attach_buf(tsstate)
+  return tsstate
+end
+
+function ts_inspect_pos(row,col)
+  local tree = parse_tree(theparser)
+  local root = tree:root()
+  local node = root:descendant_for_point_range(row,col,row,col)
+  show_node(node)
+end
+
+function show_node(node)
+  if node == nil then
+    return
+  end
+  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
+  shown_node = node
+  print(node:type())
+  local start_row, start_col, end_row, end_col = node:range()
+
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
+
+  if end_col >= 1 then
+    end_col = end_col - 1
+  end
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
+end
+
+function ts_expand_node()
+  if shown_node == nil then
+    return
+  end
+  parent = shown_node:parent()
+  show_node(parent)
+end
+
+function ts_cursor()
+  local row, col = unpack(a.nvim_win_get_cursor(0))
+  ts_inspect_pos(row-1, col)
+end
+
+if false then
+  ctree = theparser.tree
+  root = ctree:root()
+  cursor = root:to_cursor()
+  node = cursor:forward(5000) if true then return node end
+  print(#root)
+  c = root:child(50)
+  print(require'inspect'{c:extent()})
+  type(ctree.__tostring)
+  root:__tostring()
+  print(_tslua_debug())
+end
-- 
cgit 


From 0e0beef85e4d3932e0d49528d8474794f7b69b01 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Thu, 6 Jun 2019 12:20:07 +0200
Subject: tree-sitter: load parsers as .so files

---
 runtime/lua/treesitter_rt.lua | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/treesitter_rt.lua b/runtime/lua/treesitter_rt.lua
index ba7849abd6..1dea22000a 100644
--- a/runtime/lua/treesitter_rt.lua
+++ b/runtime/lua/treesitter_rt.lua
@@ -7,10 +7,6 @@ end
 local my_ns = __treesitter_rt_ns
 local my_syn_ns = __treesitter_rt_syn_ns
 
-local path = '.deps/build/src/treesitter-javascript/src/highlights.json'
-a.nvim_set_var("_ts_path", path)
-obj = a.nvim_eval("json_decode(readfile(g:_ts_path,'b'))")
-
 
 --luadev = require'luadev'
 --i = require'inspect'
@@ -62,7 +58,7 @@ function create_parser(bufnr)
   local ft = a.nvim_buf_get_option(bufnr, "filetype")
   local tsstate = {}
   tsstate.bufnr = bufnr
-  tsstate.parser = vim.ts_parser(ft)
+  tsstate.parser = vim.ts_parser(ft.."_parser.so", ft)
   parse_tree(tsstate)
   attach_buf(tsstate)
   return tsstate
-- 
cgit 


From 005b6d638caa200711bf5960e0c0d70ba5721c94 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Fri, 7 Jun 2019 14:21:00 +0200
Subject: tree-sitter: split tree-sitter lua interface from demo code

---
 runtime/lua/tree_sitter_demo.lua |  57 +++++++++++++++++++
 runtime/lua/treesitter_rt.lua    | 115 ---------------------------------------
 runtime/lua/vim/tree_sitter.lua  |  47 ++++++++++++++++
 3 files changed, 104 insertions(+), 115 deletions(-)
 create mode 100644 runtime/lua/tree_sitter_demo.lua
 delete mode 100644 runtime/lua/treesitter_rt.lua
 create mode 100644 runtime/lua/vim/tree_sitter.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/tree_sitter_demo.lua b/runtime/lua/tree_sitter_demo.lua
new file mode 100644
index 0000000000..24a0f3d622
--- /dev/null
+++ b/runtime/lua/tree_sitter_demo.lua
@@ -0,0 +1,57 @@
+local a = vim.api
+_G.a = vim.api
+
+if __treesitter_rt_ns == nil then
+    __treesitter_rt_ns = a.nvim_create_namespace("treesitter_demp")
+end
+local my_ns = __treesitter_rt_ns
+
+function ts_inspect_pos(row,col)
+  local tree = parse_tree(theparser)
+  local root = tree:root()
+  local node = root:descendant_for_point_range(row,col,row,col)
+  show_node(node)
+end
+
+function show_node(node)
+  if node == nil then
+    return
+  end
+  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
+  shown_node = node
+  print(node:type())
+  local start_row, start_col, end_row, end_col = node:range()
+
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
+
+  if end_col >= 1 then
+    end_col = end_col - 1
+  end
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
+end
+
+function ts_expand_node()
+  if shown_node == nil then
+    return
+  end
+  parent = shown_node:parent()
+  show_node(parent)
+end
+
+function ts_cursor()
+  local row, col = unpack(a.nvim_win_get_cursor(0))
+  ts_inspect_pos(row-1, col)
+end
+
+if false then
+  ctree = theparser.tree
+  root = ctree:root()
+  cursor = root:to_cursor()
+  node = cursor:forward(5000) if true then return node end
+  print(#root)
+  c = root:child(50)
+  print(require'inspect'{c:extent()})
+  type(ctree.__tostring)
+  root:__tostring()
+  print(_tslua_debug())
+end
diff --git a/runtime/lua/treesitter_rt.lua b/runtime/lua/treesitter_rt.lua
deleted file mode 100644
index 1dea22000a..0000000000
--- a/runtime/lua/treesitter_rt.lua
+++ /dev/null
@@ -1,115 +0,0 @@
-local a = vim.api
-
-if __treesitter_rt_ns == nil then
-    __treesitter_rt_ns = a.nvim_buf_add_highlight(0, 0, "", 0, 0, 0)
-    __treesitter_rt_syn_ns = a.nvim_buf_add_highlight(0, 0, "", 0, 0, 0)
-end
-local my_ns = __treesitter_rt_ns
-local my_syn_ns = __treesitter_rt_syn_ns
-
-
---luadev = require'luadev'
---i = require'inspect'
-
-
-function parse_tree(tsstate, force)
-  if tsstate.valid and not force then
-    return tsstate.tree
-  end
-  tsstate.tree = tsstate.parser:parse_buf(tsstate.bufnr)
-  tsstate.valid = true
-  return tsstate.tree
-end
-
-function the_cb(tsstate, ev, bufnr, tick, start_row, oldstopline, stop_row)
-  local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
-  -- a bit messy, should we expose edited but not reparsed tree?
-  -- are multiple edits safe in general?
-  local root = tsstate.parser:tree():root()
-  -- TODO: add proper lookup function!
-  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
-  local edit
-  if inode == nil then
-    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
-    tsstate.parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
-  else
-    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
-    local fake_rows = fakeoldstoprow-oldstopline
-    local fakestop = stop_row+fake_rows
-    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
-    tsstate.parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
-  end
-  tsstate.valid = false
-  --luadev.append_buf({i{edit.start_byte,edit.old_end_byte,edit.new_end_byte},
-  --                   i{edit.start_point, edit.old_end_point, edit.new_end_point}})
-end
-
-function attach_buf(tsstate)
-  local function cb(ev, ...)
-    return the_cb(tsstate, ev, ...)
-  end
-  a.nvim_buf_attach(tsstate.bufnr, false, {on_lines=cb})
-end
-
-function create_parser(bufnr)
-  if bufnr == 0 then
-    bufnr = a.nvim_get_current_buf()
-  end
-  local ft = a.nvim_buf_get_option(bufnr, "filetype")
-  local tsstate = {}
-  tsstate.bufnr = bufnr
-  tsstate.parser = vim.ts_parser(ft.."_parser.so", ft)
-  parse_tree(tsstate)
-  attach_buf(tsstate)
-  return tsstate
-end
-
-function ts_inspect_pos(row,col)
-  local tree = parse_tree(theparser)
-  local root = tree:root()
-  local node = root:descendant_for_point_range(row,col,row,col)
-  show_node(node)
-end
-
-function show_node(node)
-  if node == nil then
-    return
-  end
-  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
-  shown_node = node
-  print(node:type())
-  local start_row, start_col, end_row, end_col = node:range()
-
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
-
-  if end_col >= 1 then
-    end_col = end_col - 1
-  end
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
-end
-
-function ts_expand_node()
-  if shown_node == nil then
-    return
-  end
-  parent = shown_node:parent()
-  show_node(parent)
-end
-
-function ts_cursor()
-  local row, col = unpack(a.nvim_win_get_cursor(0))
-  ts_inspect_pos(row-1, col)
-end
-
-if false then
-  ctree = theparser.tree
-  root = ctree:root()
-  cursor = root:to_cursor()
-  node = cursor:forward(5000) if true then return node end
-  print(#root)
-  c = root:child(50)
-  print(require'inspect'{c:extent()})
-  type(ctree.__tostring)
-  root:__tostring()
-  print(_tslua_debug())
-end
diff --git a/runtime/lua/vim/tree_sitter.lua b/runtime/lua/vim/tree_sitter.lua
new file mode 100644
index 0000000000..a4cb3f3db6
--- /dev/null
+++ b/runtime/lua/vim/tree_sitter.lua
@@ -0,0 +1,47 @@
+local a = vim.api
+
+function parse_tree(tsstate, force)
+  if tsstate.valid and not force then
+    return tsstate.tree
+  end
+  tsstate.tree = tsstate.parser:parse_buf(tsstate.bufnr)
+  tsstate.valid = true
+  return tsstate.tree
+end
+
+local function change_cb(tsstate, ev, bufnr, tick, start_row, oldstopline, stop_row)
+  local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
+  -- a bit messy, should we expose edited but not reparsed tree?
+  -- are multiple edits safe in general?
+  local root = tsstate.parser:tree():root()
+  -- TODO: add proper lookup function!
+  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
+  if inode == nil then
+    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
+    tsstate.parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
+  else
+    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
+    local fake_rows = fakeoldstoprow-oldstopline
+    local fakestop = stop_row+fake_rows
+    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
+    tsstate.parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
+  end
+  tsstate.valid = false
+end
+
+function create_parser(bufnr)
+  if bufnr == 0 then
+    bufnr = a.nvim_get_current_buf()
+  end
+  local ft = a.nvim_buf_get_option(bufnr, "filetype")
+  local tsstate = {}
+  tsstate.bufnr = bufnr
+  tsstate.parser = vim.ts_parser(ft.."_parser.so", ft)
+  parse_tree(tsstate)
+  local function cb(ev, ...)
+    return change_cb(tsstate, ev, ...)
+  end
+  a.nvim_buf_attach(tsstate.bufnr, false, {on_lines=cb})
+  return tsstate
+end
+
-- 
cgit 


From 1e9e2451bef21ff705e677802d1b0980356f1f86 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Fri, 7 Jun 2019 18:19:59 +0200
Subject: tree-sitter: objectify API

---
 runtime/lua/tree_sitter_demo.lua |  2 +-
 runtime/lua/vim/tree_sitter.lua  | 46 +++++++++++++++++++++++-----------------
 2 files changed, 28 insertions(+), 20 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/tree_sitter_demo.lua b/runtime/lua/tree_sitter_demo.lua
index 24a0f3d622..bbfd69109d 100644
--- a/runtime/lua/tree_sitter_demo.lua
+++ b/runtime/lua/tree_sitter_demo.lua
@@ -7,7 +7,7 @@ end
 local my_ns = __treesitter_rt_ns
 
 function ts_inspect_pos(row,col)
-  local tree = parse_tree(theparser)
+  local tree = theparser:parse_tree()
   local root = tree:root()
   local node = root:descendant_for_point_range(row,col,row,col)
   show_node(node)
diff --git a/runtime/lua/vim/tree_sitter.lua b/runtime/lua/vim/tree_sitter.lua
index a4cb3f3db6..bbc4db5f29 100644
--- a/runtime/lua/vim/tree_sitter.lua
+++ b/runtime/lua/vim/tree_sitter.lua
@@ -1,47 +1,55 @@
 local a = vim.api
 
-function parse_tree(tsstate, force)
-  if tsstate.valid and not force then
-    return tsstate.tree
+local Parser = {}
+Parser.__index = Parser
+
+function Parser:parse_tree(force)
+  if self.valid and not force then
+    return self.tree
   end
-  tsstate.tree = tsstate.parser:parse_buf(tsstate.bufnr)
-  tsstate.valid = true
-  return tsstate.tree
+  self.tree = self._parser:parse_buf(self.bufnr)
+  self.valid = true
+  return self.tree
 end
 
-local function change_cb(tsstate, ev, bufnr, tick, start_row, oldstopline, stop_row)
+local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row)
   local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
   -- a bit messy, should we expose edited but not reparsed tree?
   -- are multiple edits safe in general?
-  local root = tsstate.parser:tree():root()
+  local root = self._parser:tree():root()
   -- TODO: add proper lookup function!
   local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
   if inode == nil then
     local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
-    tsstate.parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
+    self._parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
   else
     local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
     local fake_rows = fakeoldstoprow-oldstopline
     local fakestop = stop_row+fake_rows
     local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
-    tsstate.parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
+    self._parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
   end
-  tsstate.valid = false
+  self.valid = false
 end
 
-function create_parser(bufnr)
+local function create_parser(bufnr)
   if bufnr == 0 then
     bufnr = a.nvim_get_current_buf()
   end
   local ft = a.nvim_buf_get_option(bufnr, "filetype")
-  local tsstate = {}
-  tsstate.bufnr = bufnr
-  tsstate.parser = vim.ts_parser(ft.."_parser.so", ft)
-  parse_tree(tsstate)
+  local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
+  self._parser = vim._create_ts_parser(ft.."_parser.so", ft)
+  self:parse_tree()
   local function cb(ev, ...)
-    return change_cb(tsstate, ev, ...)
+    -- TODO: use weakref to self, so that the parser is free'd is no plugin is
+    -- using it.
+    return change_cb(self, ev, ...)
   end
-  a.nvim_buf_attach(tsstate.bufnr, false, {on_lines=cb})
-  return tsstate
+  a.nvim_buf_attach(self.bufnr, false, {on_lines=cb})
+  return self
 end
 
+-- TODO: weak table with reusable parser per buffer.
+
+return {create_parser=create_parser}
+
-- 
cgit 


From afba23099fccc929fd0319a9a965a7b727407c7a Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 8 Jun 2019 15:51:38 +0200
Subject: tree-sitter: support pre-registration of languages

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/tree_sitter.lua b/runtime/lua/vim/tree_sitter.lua
index bbc4db5f29..a7830bc312 100644
--- a/runtime/lua/vim/tree_sitter.lua
+++ b/runtime/lua/vim/tree_sitter.lua
@@ -38,7 +38,7 @@ local function create_parser(bufnr)
   end
   local ft = a.nvim_buf_get_option(bufnr, "filetype")
   local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
-  self._parser = vim._create_ts_parser(ft.."_parser.so", ft)
+  self._parser = vim._create_ts_parser(ft)
   self:parse_tree()
   local function cb(ev, ...)
     -- TODO: use weakref to self, so that the parser is free'd is no plugin is
-- 
cgit 


From 4ea5e63aa8c866b4fcc9d10f1a26078d2517f96a Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sun, 9 Jun 2019 13:26:48 +0200
Subject: tree-sitter: add basic testing on ci

build tree-sitter c parser on ci for testing purposes
---
 runtime/lua/vim/tree_sitter.lua | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/tree_sitter.lua b/runtime/lua/vim/tree_sitter.lua
index a7830bc312..1b5f416b67 100644
--- a/runtime/lua/vim/tree_sitter.lua
+++ b/runtime/lua/vim/tree_sitter.lua
@@ -32,11 +32,13 @@ local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row
   self.valid = false
 end
 
-local function create_parser(bufnr)
+local function create_parser(bufnr, ft)
   if bufnr == 0 then
     bufnr = a.nvim_get_current_buf()
   end
-  local ft = a.nvim_buf_get_option(bufnr, "filetype")
+  if ft == nil then
+    ft = a.nvim_buf_get_option(bufnr, "filetype")
+  end
   local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
   self._parser = vim._create_ts_parser(ft)
   self:parse_tree()
@@ -51,5 +53,5 @@ end
 
 -- TODO: weak table with reusable parser per buffer.
 
-return {create_parser=create_parser}
+return {create_parser=create_parser, add_language=vim._ts_add_language}
 
-- 
cgit 


From c8f861b739b4703b1198dc1f88b09edbeb0d9f2e Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 15 Jun 2019 12:10:12 +0200
Subject: tree-sitter: rename tree_sitter => treesitter for consistency

---
 runtime/lua/tree_sitter_demo.lua | 57 ---------------------------------------
 runtime/lua/treesitter_demo.lua  | 58 ++++++++++++++++++++++++++++++++++++++++
 runtime/lua/vim/tree_sitter.lua  | 57 ---------------------------------------
 runtime/lua/vim/treesitter.lua   | 57 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 114 deletions(-)
 delete mode 100644 runtime/lua/tree_sitter_demo.lua
 create mode 100644 runtime/lua/treesitter_demo.lua
 delete mode 100644 runtime/lua/vim/tree_sitter.lua
 create mode 100644 runtime/lua/vim/treesitter.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/tree_sitter_demo.lua b/runtime/lua/tree_sitter_demo.lua
deleted file mode 100644
index bbfd69109d..0000000000
--- a/runtime/lua/tree_sitter_demo.lua
+++ /dev/null
@@ -1,57 +0,0 @@
-local a = vim.api
-_G.a = vim.api
-
-if __treesitter_rt_ns == nil then
-    __treesitter_rt_ns = a.nvim_create_namespace("treesitter_demp")
-end
-local my_ns = __treesitter_rt_ns
-
-function ts_inspect_pos(row,col)
-  local tree = theparser:parse_tree()
-  local root = tree:root()
-  local node = root:descendant_for_point_range(row,col,row,col)
-  show_node(node)
-end
-
-function show_node(node)
-  if node == nil then
-    return
-  end
-  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
-  shown_node = node
-  print(node:type())
-  local start_row, start_col, end_row, end_col = node:range()
-
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
-
-  if end_col >= 1 then
-    end_col = end_col - 1
-  end
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
-end
-
-function ts_expand_node()
-  if shown_node == nil then
-    return
-  end
-  parent = shown_node:parent()
-  show_node(parent)
-end
-
-function ts_cursor()
-  local row, col = unpack(a.nvim_win_get_cursor(0))
-  ts_inspect_pos(row-1, col)
-end
-
-if false then
-  ctree = theparser.tree
-  root = ctree:root()
-  cursor = root:to_cursor()
-  node = cursor:forward(5000) if true then return node end
-  print(#root)
-  c = root:child(50)
-  print(require'inspect'{c:extent()})
-  type(ctree.__tostring)
-  root:__tostring()
-  print(_tslua_debug())
-end
diff --git a/runtime/lua/treesitter_demo.lua b/runtime/lua/treesitter_demo.lua
new file mode 100644
index 0000000000..82c36f94c0
--- /dev/null
+++ b/runtime/lua/treesitter_demo.lua
@@ -0,0 +1,58 @@
+-- TODO: externalize this
+local a = vim.api
+_G.a = vim.api
+
+if __treesitter_rt_ns == nil then
+    __treesitter_rt_ns = a.nvim_create_namespace("treesitter_demp")
+end
+local my_ns = __treesitter_rt_ns
+
+function ts_inspect_pos(row,col)
+  local tree = theparser:parse_tree()
+  local root = tree:root()
+  local node = root:descendant_for_point_range(row,col,row,col)
+  show_node(node)
+end
+
+function show_node(node)
+  if node == nil then
+    return
+  end
+  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
+  shown_node = node
+  print(node:type())
+  local start_row, start_col, end_row, end_col = node:range()
+
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
+
+  if end_col >= 1 then
+    end_col = end_col - 1
+  end
+  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
+end
+
+function ts_expand_node()
+  if shown_node == nil then
+    return
+  end
+  parent = shown_node:parent()
+  show_node(parent)
+end
+
+function ts_cursor()
+  local row, col = unpack(a.nvim_win_get_cursor(0))
+  ts_inspect_pos(row-1, col)
+end
+
+if false then
+  ctree = theparser.tree
+  root = ctree:root()
+  cursor = root:to_cursor()
+  node = cursor:forward(5000) if true then return node end
+  print(#root)
+  c = root:child(50)
+  print(require'inspect'{c:extent()})
+  type(ctree.__tostring)
+  root:__tostring()
+  print(_tslua_debug())
+end
diff --git a/runtime/lua/vim/tree_sitter.lua b/runtime/lua/vim/tree_sitter.lua
deleted file mode 100644
index 1b5f416b67..0000000000
--- a/runtime/lua/vim/tree_sitter.lua
+++ /dev/null
@@ -1,57 +0,0 @@
-local a = vim.api
-
-local Parser = {}
-Parser.__index = Parser
-
-function Parser:parse_tree(force)
-  if self.valid and not force then
-    return self.tree
-  end
-  self.tree = self._parser:parse_buf(self.bufnr)
-  self.valid = true
-  return self.tree
-end
-
-local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row)
-  local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
-  -- a bit messy, should we expose edited but not reparsed tree?
-  -- are multiple edits safe in general?
-  local root = self._parser:tree():root()
-  -- TODO: add proper lookup function!
-  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
-  if inode == nil then
-    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
-    self._parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
-  else
-    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
-    local fake_rows = fakeoldstoprow-oldstopline
-    local fakestop = stop_row+fake_rows
-    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
-    self._parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
-  end
-  self.valid = false
-end
-
-local function create_parser(bufnr, ft)
-  if bufnr == 0 then
-    bufnr = a.nvim_get_current_buf()
-  end
-  if ft == nil then
-    ft = a.nvim_buf_get_option(bufnr, "filetype")
-  end
-  local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
-  self._parser = vim._create_ts_parser(ft)
-  self:parse_tree()
-  local function cb(ev, ...)
-    -- TODO: use weakref to self, so that the parser is free'd is no plugin is
-    -- using it.
-    return change_cb(self, ev, ...)
-  end
-  a.nvim_buf_attach(self.bufnr, false, {on_lines=cb})
-  return self
-end
-
--- TODO: weak table with reusable parser per buffer.
-
-return {create_parser=create_parser, add_language=vim._ts_add_language}
-
diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
new file mode 100644
index 0000000000..1b5f416b67
--- /dev/null
+++ b/runtime/lua/vim/treesitter.lua
@@ -0,0 +1,57 @@
+local a = vim.api
+
+local Parser = {}
+Parser.__index = Parser
+
+function Parser:parse_tree(force)
+  if self.valid and not force then
+    return self.tree
+  end
+  self.tree = self._parser:parse_buf(self.bufnr)
+  self.valid = true
+  return self.tree
+end
+
+local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row)
+  local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
+  -- a bit messy, should we expose edited but not reparsed tree?
+  -- are multiple edits safe in general?
+  local root = self._parser:tree():root()
+  -- TODO: add proper lookup function!
+  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
+  if inode == nil then
+    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
+    self._parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
+  else
+    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
+    local fake_rows = fakeoldstoprow-oldstopline
+    local fakestop = stop_row+fake_rows
+    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
+    self._parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
+  end
+  self.valid = false
+end
+
+local function create_parser(bufnr, ft)
+  if bufnr == 0 then
+    bufnr = a.nvim_get_current_buf()
+  end
+  if ft == nil then
+    ft = a.nvim_buf_get_option(bufnr, "filetype")
+  end
+  local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
+  self._parser = vim._create_ts_parser(ft)
+  self:parse_tree()
+  local function cb(ev, ...)
+    -- TODO: use weakref to self, so that the parser is free'd is no plugin is
+    -- using it.
+    return change_cb(self, ev, ...)
+  end
+  a.nvim_buf_attach(self.bufnr, false, {on_lines=cb})
+  return self
+end
+
+-- TODO: weak table with reusable parser per buffer.
+
+return {create_parser=create_parser, add_language=vim._ts_add_language}
+
-- 
cgit 


From d24dec596c25690aba0aca658546ffdfcc6a952c Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 15 Jun 2019 14:05:35 +0200
Subject: tree-sitter: inspect language

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 1b5f416b67..3a1b1fc4b3 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -53,5 +53,9 @@ end
 
 -- TODO: weak table with reusable parser per buffer.
 
-return {create_parser=create_parser, add_language=vim._ts_add_language}
+return {
+  create_parser=create_parser,
+  add_language=vim._ts_add_language,
+  inspect_language=vim._ts_inspect_language,
+}
 
-- 
cgit 


From 167a1cfdef0c4b3526830ad0356f06bf480df6af Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Mon, 17 Jun 2019 21:46:31 +0200
Subject: tree-sitter: improve parser API (shared parser between plugins)

---
 runtime/lua/vim/treesitter.lua | 57 +++++++++++++++++++++++++++++++-----------
 1 file changed, 42 insertions(+), 15 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 3a1b1fc4b3..f26d63d6ce 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -3,8 +3,13 @@ local a = vim.api
 local Parser = {}
 Parser.__index = Parser
 
-function Parser:parse_tree(force)
-  if self.valid and not force then
+-- TODO(bfredl): currently we retain parsers for the lifetime of the buffer.
+-- Consider use weak references to release parser if all plugins are done with
+-- it.
+local parsers = {}
+
+function Parser:parse()
+  if self.valid then
     return self.tree
   end
   self.tree = self._parser:parse_buf(self.bufnr)
@@ -12,7 +17,7 @@ function Parser:parse_tree(force)
   return self.tree
 end
 
-local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row)
+local function on_lines(self, bufnr, _, start_row, oldstopline, stop_row)
   local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
   -- a bit messy, should we expose edited but not reparsed tree?
   -- are multiple edits safe in general?
@@ -21,41 +26,63 @@ local function change_cb(self, ev, bufnr, tick, start_row, oldstopline, stop_row
   local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
   if inode == nil then
     local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
-    self._parser:edit(start_byte,stop_byte,stop_byte,start_row,0,stop_row,0,stop_row,0)
+    self._parser:edit(start_byte,stop_byte,stop_byte,
+                      start_row,0,stop_row,0,stop_row,0)
   else
     local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
     local fake_rows = fakeoldstoprow-oldstopline
     local fakestop = stop_row+fake_rows
     local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
-    self._parser:edit(start_byte,fakebyteoldstop,fakebytestop,start_row,0,fakeoldstoprow,fakeoldstopcol,fakestop,fakeoldstopcol)
+    self._parser:edit(start_byte, fakebyteoldstop, fakebytestop,
+                      start_row, 0,
+                      fakeoldstoprow, fakeoldstopcol,
+                      fakestop, fakeoldstopcol)
   end
   self.valid = false
 end
 
-local function create_parser(bufnr, ft)
+local function create_parser(bufnr, ft, id)
   if bufnr == 0 then
     bufnr = a.nvim_get_current_buf()
   end
-  if ft == nil then
-    ft = a.nvim_buf_get_option(bufnr, "filetype")
-  end
   local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
   self._parser = vim._create_ts_parser(ft)
-  self:parse_tree()
-  local function cb(ev, ...)
+  self:parse()
     -- TODO: use weakref to self, so that the parser is free'd is no plugin is
     -- using it.
-    return change_cb(self, ev, ...)
+  local function lines_cb(ev, ...)
+    return on_lines(self, ...)
   end
-  a.nvim_buf_attach(self.bufnr, false, {on_lines=cb})
+  local detach_cb = nil
+  if id ~= nil then
+    detach_cb = function()
+      if parsers[id] == self then
+        parsers[id] = nil
+      end
+    end
+  end
+  a.nvim_buf_attach(self.bufnr, false, {on_lines=lines_cb, on_detach=detach_cb})
   return self
 end
 
--- TODO: weak table with reusable parser per buffer.
+local function get_parser(bufnr, ft)
+  if bufnr == nil or bufnr == 0 then
+    bufnr = a.nvim_get_current_buf()
+  end
+  if ft == nil then
+    ft = a.nvim_buf_get_option(bufnr, "filetype")
+  end
+  local id = tostring(bufnr)..'_'..ft
+
+  if parsers[id] == nil then
+    parsers[id] = create_parser(bufnr, ft, id)
+  end
+  return parsers[id]
+end
 
 return {
+  get_parser=get_parser,
   create_parser=create_parser,
   add_language=vim._ts_add_language,
   inspect_language=vim._ts_inspect_language,
 }
-
-- 
cgit 


From 06ee45b9b1c14c7ce6cb23403cdbe2852d495cad Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Fri, 21 Jun 2019 14:14:51 +0200
Subject: tree-sitter: fix lint, delete "demo" plugin (replaced by functional
 tests)

---
 runtime/lua/treesitter_demo.lua | 58 -----------------------------------------
 runtime/lua/vim/treesitter.lua  |  2 +-
 2 files changed, 1 insertion(+), 59 deletions(-)
 delete mode 100644 runtime/lua/treesitter_demo.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/treesitter_demo.lua b/runtime/lua/treesitter_demo.lua
deleted file mode 100644
index 82c36f94c0..0000000000
--- a/runtime/lua/treesitter_demo.lua
+++ /dev/null
@@ -1,58 +0,0 @@
--- TODO: externalize this
-local a = vim.api
-_G.a = vim.api
-
-if __treesitter_rt_ns == nil then
-    __treesitter_rt_ns = a.nvim_create_namespace("treesitter_demp")
-end
-local my_ns = __treesitter_rt_ns
-
-function ts_inspect_pos(row,col)
-  local tree = theparser:parse_tree()
-  local root = tree:root()
-  local node = root:descendant_for_point_range(row,col,row,col)
-  show_node(node)
-end
-
-function show_node(node)
-  if node == nil then
-    return
-  end
-  a.nvim_buf_clear_highlight(0, my_ns, 0, -1)
-  shown_node = node
-  print(node:type())
-  local start_row, start_col, end_row, end_col = node:range()
-
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", start_row, start_col, start_col+1)
-
-  if end_col >= 1 then
-    end_col = end_col - 1
-  end
-  a.nvim_buf_add_highlight(0, my_ns, "ErrorMsg", end_row, end_col, end_col+1)
-end
-
-function ts_expand_node()
-  if shown_node == nil then
-    return
-  end
-  parent = shown_node:parent()
-  show_node(parent)
-end
-
-function ts_cursor()
-  local row, col = unpack(a.nvim_win_get_cursor(0))
-  ts_inspect_pos(row-1, col)
-end
-
-if false then
-  ctree = theparser.tree
-  root = ctree:root()
-  cursor = root:to_cursor()
-  node = cursor:forward(5000) if true then return node end
-  print(#root)
-  c = root:child(50)
-  print(require'inspect'{c:extent()})
-  type(ctree.__tostring)
-  root:__tostring()
-  print(_tslua_debug())
-end
diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index f26d63d6ce..8aa170061b 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -50,7 +50,7 @@ local function create_parser(bufnr, ft, id)
   self:parse()
     -- TODO: use weakref to self, so that the parser is free'd is no plugin is
     -- using it.
-  local function lines_cb(ev, ...)
+  local function lines_cb(_, ...)
     return on_lines(self, ...)
   end
   local detach_cb = nil
-- 
cgit 


From f86a2c33a2e54193598be1d8c856363e02b91e37 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Mon, 5 Aug 2019 19:37:17 +0200
Subject: tree-sitter: simplify editing using the new old_byte_size parameter

---
 runtime/lua/vim/treesitter.lua | 25 +++++--------------------
 1 file changed, 5 insertions(+), 20 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 8aa170061b..69b1ac8716 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -17,27 +17,12 @@ function Parser:parse()
   return self.tree
 end
 
-local function on_lines(self, bufnr, _, start_row, oldstopline, stop_row)
+local function on_lines(self, bufnr, _, start_row, old_stop_row, stop_row, old_byte_size)
   local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
-  -- a bit messy, should we expose edited but not reparsed tree?
-  -- are multiple edits safe in general?
-  local root = self._parser:tree():root()
-  -- TODO: add proper lookup function!
-  local inode = root:descendant_for_point_range(oldstopline+9000,0, oldstopline,0)
-  if inode == nil then
-    local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
-    self._parser:edit(start_byte,stop_byte,stop_byte,
-                      start_row,0,stop_row,0,stop_row,0)
-  else
-    local fakeoldstoprow, fakeoldstopcol, fakebyteoldstop = inode:start()
-    local fake_rows = fakeoldstoprow-oldstopline
-    local fakestop = stop_row+fake_rows
-    local fakebytestop = a.nvim_buf_get_offset(bufnr,fakestop)+fakeoldstopcol
-    self._parser:edit(start_byte, fakebyteoldstop, fakebytestop,
-                      start_row, 0,
-                      fakeoldstoprow, fakeoldstopcol,
-                      fakestop, fakeoldstopcol)
-  end
+  local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
+  local old_stop_byte = start_byte + old_byte_size
+  self._parser:edit(start_byte,old_stop_byte,stop_byte,
+                    start_row,0,old_stop_row,0,stop_row,0)
   self.valid = false
 end
 
-- 
cgit 


From c844f986d4c8f34bbe60591270178504b7045a7a Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 28 Sep 2019 14:04:05 +0200
Subject: tree-sitter: use "module" pattern in lua source

---
 runtime/lua/vim/treesitter.lua | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 69b1ac8716..e0202927bb 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -1,13 +1,13 @@
 local a = vim.api
 
-local Parser = {}
-Parser.__index = Parser
-
 -- TODO(bfredl): currently we retain parsers for the lifetime of the buffer.
 -- Consider use weak references to release parser if all plugins are done with
 -- it.
 local parsers = {}
 
+local Parser = {}
+Parser.__index = Parser
+
 function Parser:parse()
   if self.valid then
     return self.tree
@@ -17,7 +17,7 @@ function Parser:parse()
   return self.tree
 end
 
-local function on_lines(self, bufnr, _, start_row, old_stop_row, stop_row, old_byte_size)
+function Parser:_on_lines(bufnr, _, start_row, old_stop_row, stop_row, old_byte_size)
   local start_byte = a.nvim_buf_get_offset(bufnr,start_row)
   local stop_byte = a.nvim_buf_get_offset(bufnr,stop_row)
   local old_stop_byte = start_byte + old_byte_size
@@ -26,17 +26,22 @@ local function on_lines(self, bufnr, _, start_row, old_stop_row, stop_row, old_b
   self.valid = false
 end
 
-local function create_parser(bufnr, ft, id)
+local module = {
+  add_language=vim._ts_add_language,
+  inspect_language=vim._ts_inspect_language,
+}
+
+function module.create_parser(bufnr, ft, id)
   if bufnr == 0 then
     bufnr = a.nvim_get_current_buf()
   end
   local self = setmetatable({bufnr=bufnr, valid=false}, Parser)
   self._parser = vim._create_ts_parser(ft)
   self:parse()
-    -- TODO: use weakref to self, so that the parser is free'd is no plugin is
+    -- TODO(bfredl): use weakref to self, so that the parser is free'd is no plugin is
     -- using it.
   local function lines_cb(_, ...)
-    return on_lines(self, ...)
+    return self:_on_lines(...)
   end
   local detach_cb = nil
   if id ~= nil then
@@ -50,7 +55,7 @@ local function create_parser(bufnr, ft, id)
   return self
 end
 
-local function get_parser(bufnr, ft)
+function module.get_parser(bufnr, ft)
   if bufnr == nil or bufnr == 0 then
     bufnr = a.nvim_get_current_buf()
   end
@@ -60,14 +65,9 @@ local function get_parser(bufnr, ft)
   local id = tostring(bufnr)..'_'..ft
 
   if parsers[id] == nil then
-    parsers[id] = create_parser(bufnr, ft, id)
+    parsers[id] = module.create_parser(bufnr, ft, id)
   end
   return parsers[id]
 end
 
-return {
-  get_parser=get_parser,
-  create_parser=create_parser,
-  add_language=vim._ts_add_language,
-  inspect_language=vim._ts_inspect_language,
-}
+return module
-- 
cgit 


From 996a057fb9b4b7d791adad19f07b2f9c53a88ab5 Mon Sep 17 00:00:00 2001
From: Hirokazu Hata <h.hata.ai.t@gmail.com>
Date: Mon, 21 Oct 2019 23:46:28 +0900
Subject: lua/stdlib: adjust some validation messages #11271

close #11271
---
 runtime/lua/vim/shared.lua | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index cd6f8a04d8..220b6c6c7c 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -44,9 +44,9 @@ end
 --@param plain If `true` use `sep` literally (passed to String.find)
 --@returns Iterator over the split components
 local function gsplit(s, sep, plain)
-  assert(type(s) == "string")
-  assert(type(sep) == "string")
-  assert(type(plain) == "boolean" or type(plain) == "nil")
+  assert(type(s) == "string", string.format("Expected string, got %s", type(s)))
+  assert(type(sep) == "string", string.format("Expected string, got %s", type(sep)))
+  assert(type(plain) == "boolean" or type(plain) == "nil", string.format("Expected boolean or nil, got %s", type(plain)))
 
   local start = 1
   local done = false
@@ -103,9 +103,8 @@ end
 --@param value Value to compare
 --@returns true if `t` contains `value`
 local function tbl_contains(t, value)
-  if type(t) ~= 'table' then
-    error('t must be a table')
-  end
+  assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
+
   for _,v in ipairs(t) do
     if v == value then
       return true
@@ -174,7 +173,7 @@ end
 --@param s String to trim
 --@returns String with whitespace removed from its beginning and end
 local function trim(s)
-  assert(type(s) == 'string', 'Only strings can be trimmed')
+  assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
   return s:match('^%s*(.*%S)') or ''
 end
 
@@ -184,7 +183,7 @@ end
 --@param s  String to escape
 --@returns  %-escaped pattern string
 local function pesc(s)
-  assert(type(s) == 'string')
+  assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
-- 
cgit 


From c2fc4255f92157b65a2f0d5b299027195541d6b8 Mon Sep 17 00:00:00 2001
From: Hirokazu Hata <h.hata.ai.t@gmail.com>
Date: Wed, 23 Oct 2019 10:50:42 +0900
Subject: runtime: Use module pattern with vim/shared.lua

It's a bit cumbersome for us to add an export target every time we define a new function.
It's also cumbersome to care about the order of definition when creating a new function by referring to other functions in the module.
---
 runtime/lua/vim/shared.lua | 75 +++++++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 41 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 220b6c6c7c..7727fdbab0 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -4,34 +4,37 @@
 -- test-suite. If, in the future, Nvim itself is used to run the test-suite
 -- instead of "vanilla Lua", these functions could move to src/nvim/lua/vim.lua
 
+local vim = {}
 
 --- Returns a deep copy of the given object. Non-table objects are copied as
 --- in a typical Lua assignment, whereas table objects are copied recursively.
 ---
 --@param orig Table to copy
 --@returns New table of copied keys and (nested) values.
-local function deepcopy(orig)
-  error(orig)
-end
-local function _id(v)
-  return v
-end
-local deepcopy_funcs = {
-  table = function(orig)
-    local copy = {}
-    for k, v in pairs(orig) do
-      copy[deepcopy(k)] = deepcopy(v)
-    end
-    return copy
-  end,
-  number = _id,
-  string = _id,
-  ['nil'] = _id,
-  boolean = _id,
-}
-deepcopy = function(orig)
-  return deepcopy_funcs[type(orig)](orig)
-end
+function vim.deepcopy(orig) end  -- luacheck: no unused
+vim.deepcopy = (function()
+  local function _id(v)
+    return v
+  end
+
+  local deepcopy_funcs = {
+    table = function(orig)
+      local copy = {}
+      for k, v in pairs(orig) do
+        copy[vim.deepcopy(k)] = vim.deepcopy(v)
+      end
+      return copy
+    end,
+    number = _id,
+    string = _id,
+    ['nil'] = _id,
+    boolean = _id,
+  }
+
+  return function(orig)
+    return deepcopy_funcs[type(orig)](orig)
+  end
+end)()
 
 --- Splits a string at each instance of a separator.
 ---
@@ -43,7 +46,7 @@ end
 --@param sep Separator string or pattern
 --@param plain If `true` use `sep` literally (passed to String.find)
 --@returns Iterator over the split components
-local function gsplit(s, sep, plain)
+function vim.gsplit(s, sep, plain)
   assert(type(s) == "string", string.format("Expected string, got %s", type(s)))
   assert(type(sep) == "string", string.format("Expected string, got %s", type(sep)))
   assert(type(plain) == "boolean" or type(plain) == "nil", string.format("Expected boolean or nil, got %s", type(plain)))
@@ -92,8 +95,8 @@ end
 --@param sep Separator string or pattern
 --@param plain If `true` use `sep` literally (passed to String.find)
 --@returns List-like table of the split components.
-local function split(s,sep,plain)
-  local t={} for c in gsplit(s, sep, plain) do table.insert(t,c) end
+function vim.split(s,sep,plain)
+  local t={} for c in vim.gsplit(s, sep, plain) do table.insert(t,c) end
   return t
 end
 
@@ -102,7 +105,7 @@ end
 --@param t Table to check
 --@param value Value to compare
 --@returns true if `t` contains `value`
-local function tbl_contains(t, value)
+function vim.tbl_contains(t, value)
   assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
 
   for _,v in ipairs(t) do
@@ -122,7 +125,7 @@ end
 ---      - "keep":  use value from the leftmost map
 ---      - "force": use value from the rightmost map
 --@param ... Two or more map-like tables.
-local function tbl_extend(behavior, ...)
+function vim.tbl_extend(behavior, ...)
   if (behavior ~= 'error' and behavior ~= 'keep' and behavior ~= 'force') then
     error('invalid "behavior": '..tostring(behavior))
   end
@@ -149,7 +152,7 @@ end
 ---
 --@param t List-like table
 --@returns Flattened copy of the given list-like table.
-local function tbl_flatten(t)
+function vim.tbl_flatten(t)
   -- From https://github.com/premake/premake-core/blob/master/src/base/table.lua
   local result = {}
   local function _tbl_flatten(_t)
@@ -172,7 +175,7 @@ end
 --@see https://www.lua.org/pil/20.2.html
 --@param s String to trim
 --@returns String with whitespace removed from its beginning and end
-local function trim(s)
+function vim.trim(s)
   assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
   return s:match('^%s*(.*%S)') or ''
 end
@@ -182,19 +185,9 @@ end
 --@see https://github.com/rxi/lume
 --@param s  String to escape
 --@returns  %-escaped pattern string
-local function pesc(s)
+function vim.pesc(s)
   assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
-local module = {
-  deepcopy = deepcopy,
-  gsplit = gsplit,
-  pesc = pesc,
-  split = split,
-  tbl_contains = tbl_contains,
-  tbl_extend = tbl_extend,
-  tbl_flatten = tbl_flatten,
-  trim = trim,
-}
-return module
+return vim
-- 
cgit 


From 474d0bcbf724c7eed740f60391a0ed35d651e1d3 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sun, 27 Oct 2019 20:49:03 +0100
Subject: lua: vim.rpcrequest, vim.rpcnotify, vim.NIL

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/inspect.lua b/runtime/lua/vim/inspect.lua
index 7cb40ca64d..0f3b908dc1 100644
--- a/runtime/lua/vim/inspect.lua
+++ b/runtime/lua/vim/inspect.lua
@@ -289,7 +289,7 @@ function Inspector:putValue(v)
   if tv == 'string' then
     self:puts(smartQuote(escape(v)))
   elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
-         tv == 'cdata' or tv == 'ctype' then
+         tv == 'cdata' or tv == 'ctype' or (vim and v == vim.NIL) then
     self:puts(tostring(v))
   elseif tv == 'table' then
     self:putTable(v)
-- 
cgit 


From 678a51b1da0c0535299341e7a598c080adcf8553 Mon Sep 17 00:00:00 2001
From: Hirokazu Hata <h.hata.ai.t@gmail.com>
Date: Mon, 28 Oct 2019 20:52:18 +0900
Subject: Lua: vim.validate()

We often want to do type checking of public function arguments.

- test: Rename utility_function_spec.lua to vim_spec.lua
- .luacov: Map lua module names
---
 runtime/lua/vim/shared.lua | 74 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 7727fdbab0..9f656774a1 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -190,4 +190,78 @@ function vim.pesc(s)
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
+--- Type checking validation function
+---
+--- Examples:
+--- <pre>
+---  validate({ arg={ { 'foo' }, 'table' }})                                     --> Nop
+---  validate({ arg={ 1, 'table' } })                                            --> error("arg: expected table, got number")
+---  validate({ arg1={ { 'foo' }, 'table' }, arg2={ 1, 'string' } })             --> error("arg2: expected string, got number")
+---  validate({ arg={ 3, function(a) return (a % 2) == 0  end, 'even number' }}) --> error("arg: expected even number, got 3")
+--- </pre>
+---
+---@param ... Table or list of table. That table is "argument_name = { validation_target, type_name (, whether nil is allowed) }"
+--- or "argument_name = { validation_target, validation function, expected_description }".
+--- The following can be used as type_names:
+---     - table or t
+---     - string or s
+---     - number or n
+---     - boolean or b
+---     - function or f
+---     - nil
+---     - thread
+---     - userdata
+function vim.validate(opt)
+  local function _type_name(t)
+    if t == 't' or t == 'table' then return 'table'  end
+    if t == 's' or t == 'string' then return 'string'  end
+    if t == 'n' or t == 'number' then return 'number'  end
+    if t == 'b' or t == 'boolean' then return 'boolean'  end
+    if t == 'f' or t == 'function' then return 'function' end
+    if t == 'c' then return 'callable' end
+    if t == 'nil' then return 'nil' end
+    if t == 'thread' or t == 'thread' then return 'thread'  end
+    if t == 'userdata' then return 'userdata' end
+    if vim.is_callable(t) then return end
+
+    error(string.format("Invalid type name '%s'. See \":help validate\" for more info.", t))
+  end
+  local function _check_type(target, expected_type)
+    if expected_type == 'callable' then
+      return vim.is_callable(target)
+    else
+      return type(target) == expected_type
+    end
+  end
+
+  for arg, v in pairs(opt) do
+    assert(type(arg) == 'string',string.format('Expected string, got %s', type(arg)))
+    assert(type(v) == 'table', string.format('Expected table, got %s', type(v)))
+
+    local actual_arg_type = type(v[1])
+    local expected_type = _type_name(v[2])
+
+    if expected_type then
+      if v[3] == true then
+        assert(_check_type(v[1], expected_type) or actual_arg_type == 'nil', string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type))
+      else
+        assert(_check_type(v[1], expected_type), string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type))
+      end
+    else
+      assert(v[2](v[1]), string.format("%s: expected %s, got %s", arg, v[3], v[1]))
+    end
+  end
+end
+
+--- Return whether an object can call be used as a function.
+---
+--@param f Any type of variable
+--@return Boolean
+function vim.is_callable(f)
+  if type(f) == 'function' then return true end
+  local m = getmetatable(f)
+  if m == nil then return false end
+  return type(m.__call) == 'function'
+end
+
 return vim
-- 
cgit 


From 7aa4042d3bddf2f39d048b9ba1dd7adf2193d4eb Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 10 Nov 2019 19:58:14 -0800
Subject: Lua: vim.validate()

---
 runtime/lua/vim/shared.lua | 111 +++++++++++++++++++++++++--------------------
 1 file changed, 62 insertions(+), 49 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 9f656774a1..7d2523403a 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -190,68 +190,81 @@ function vim.pesc(s)
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
---- Type checking validation function
+--- Validates a parameter specification (types and values).
 ---
 --- Examples:
 --- <pre>
----  validate({ arg={ { 'foo' }, 'table' }})                                     --> Nop
----  validate({ arg={ 1, 'table' } })                                            --> error("arg: expected table, got number")
----  validate({ arg1={ { 'foo' }, 'table' }, arg2={ 1, 'string' } })             --> error("arg2: expected string, got number")
----  validate({ arg={ 3, function(a) return (a % 2) == 0  end, 'even number' }}) --> error("arg: expected even number, got 3")
+---  function user.new(name, age, hobbies)
+---    vim.validate{
+---      name={name, 'string'},
+---      age={age, 'number'},
+---      hobbies={hobbies, 'table'},
+---    }
+---    ...
+---  end
+--
+---  vim.validate{ arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
+---     => NOP (success)
+---  vim.validate{arg1={1, 'table'}}
+---     => error("arg1: expected table, got number")
+---  vim.validate{arg1={{'foo'}, 'table'}, arg2={1, 'string'}}
+---     => error("arg2: expected string, got number")
+---  vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
+---     => error("arg1: expected even number, got 3")
 --- </pre>
 ---
----@param ... Table or list of table. That table is "argument_name = { validation_target, type_name (, whether nil is allowed) }"
---- or "argument_name = { validation_target, validation function, expected_description }".
---- The following can be used as type_names:
----     - table or t
----     - string or s
----     - number or n
----     - boolean or b
----     - function or f
----     - nil
----     - thread
----     - userdata
-function vim.validate(opt)
-  local function _type_name(t)
-    if t == 't' or t == 'table' then return 'table'  end
-    if t == 's' or t == 'string' then return 'string'  end
-    if t == 'n' or t == 'number' then return 'number'  end
-    if t == 'b' or t == 'boolean' then return 'boolean'  end
-    if t == 'f' or t == 'function' then return 'function' end
-    if t == 'c' then return 'callable' end
-    if t == 'nil' then return 'nil' end
-    if t == 'thread' or t == 'thread' then return 'thread'  end
-    if t == 'userdata' then return 'userdata' end
-    if vim.is_callable(t) then return end
-
-    error(string.format("Invalid type name '%s'. See \":help validate\" for more info.", t))
-  end
-  local function _check_type(target, expected_type)
-    if expected_type == 'callable' then
-      return vim.is_callable(target)
-    else
-      return type(target) == expected_type
+--@param opt Map of parameter names to validations. Each key is a parameter
+---          name; each value is a tuple in one of these forms:
+---          1. {arg_value, type_name, optional}
+---             - arg_value: argument value
+---             - type_name: string type name, one of: ("table", "t", "string",
+---               "s", "number", "n", "boolean", "b", "function", "f", "nil",
+---               "thread", "userdata")
+---             - optional: (optional) boolean, if true, `nil` is valid
+---          2. {arg_value, fn, msg}
+---             - arg_value: argument value
+---             - fn: any function accepting one argument, returns true if and
+---               only if the argument is valid
+---             - msg: (optional) error string if validation fails
+function vim.validate(opt) end  -- luacheck: no unused
+vim.validate = (function()
+  local type_names = {
+    t='table', s='string', n='number', b='boolean', f='function', c='callable',
+    ['table']='table', ['string']='string', ['number']='number',
+    ['boolean']='boolean', ['function']='function', ['callable']='callable',
+    ['nil']='nil', ['thread']='thread', ['userdata']='userdata',
+  }
+  local function type_name(t)
+    local tname = type_names[t]
+    if tname == nil then
+      error(string.format('invalid type name: %s', tostring(t)))
     end
+    return tname
+  end
+  local function is_type(val, t)
+    return t == 'callable' and vim.is_callable(val) or type(val) == t
   end
 
-  for arg, v in pairs(opt) do
-    assert(type(arg) == 'string',string.format('Expected string, got %s', type(arg)))
-    assert(type(v) == 'table', string.format('Expected table, got %s', type(v)))
+  return function(opt)
+    assert(type(opt) == 'table', string.format('opt: expected table, got %s', type(opt)))
+    for param_name, spec in pairs(opt) do
+      assert(type(spec) == 'table', string.format('%s: expected table, got %s', param_name, type(spec)))
 
-    local actual_arg_type = type(v[1])
-    local expected_type = _type_name(v[2])
+      local val = spec[1]   -- Argument value.
+      local t = spec[2]     -- Type name, or callable.
+      local optional = (true == spec[3])
 
-    if expected_type then
-      if v[3] == true then
-        assert(_check_type(v[1], expected_type) or actual_arg_type == 'nil', string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type))
-      else
-        assert(_check_type(v[1], expected_type), string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type))
+      if not vim.is_callable(t) then  -- Check type name.
+        if not (optional or type(val) == 'nil') and not is_type(val, type_name(t)) then
+          error(string.format("%s: expected %s, got %s", param_name, type_name(t), type(val)))
+        end
+      elseif not t(val) then  -- Check user-provided validation function.
+        error(string.format("%s: expected %s, got %s", param_name, spec[3], val))
       end
-    else
-      assert(v[2](v[1]), string.format("%s: expected %s, got %s", arg, v[3], v[1]))
     end
+    return true
   end
-end
+end)()
 
 --- Return whether an object can call be used as a function.
 ---
-- 
cgit 


From a0d992785feeefaea2810dcf08564fd8bea8cab9 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 10 Nov 2019 22:18:59 -0800
Subject: Lua: Use vim.validate() instead of assert()

---
 runtime/lua/vim/shared.lua | 47 +++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 7d2523403a..e987e07a2a 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -47,9 +47,7 @@ end)()
 --@param plain If `true` use `sep` literally (passed to String.find)
 --@returns Iterator over the split components
 function vim.gsplit(s, sep, plain)
-  assert(type(s) == "string", string.format("Expected string, got %s", type(s)))
-  assert(type(sep) == "string", string.format("Expected string, got %s", type(sep)))
-  assert(type(plain) == "boolean" or type(plain) == "nil", string.format("Expected boolean or nil, got %s", type(plain)))
+  vim.validate{s={s,'s'},sep={sep,'s'},plain={plain,'b',true}}
 
   local start = 1
   local done = false
@@ -106,7 +104,7 @@ end
 --@param value Value to compare
 --@returns true if `t` contains `value`
 function vim.tbl_contains(t, value)
-  assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
+  vim.validate{t={t,'t'}}
 
   for _,v in ipairs(t) do
     if v == value then
@@ -176,7 +174,7 @@ end
 --@param s String to trim
 --@returns String with whitespace removed from its beginning and end
 function vim.trim(s)
-  assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
+  vim.validate{s={s,'s'}}
   return s:match('^%s*(.*%S)') or ''
 end
 
@@ -186,13 +184,13 @@ end
 --@param s  String to escape
 --@returns  %-escaped pattern string
 function vim.pesc(s)
-  assert(type(s) == 'string', string.format("Expected string, got %s", type(s)))
+  vim.validate{s={s,'s'}}
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
 --- Validates a parameter specification (types and values).
 ---
---- Examples:
+--- Usage example:
 --- <pre>
 ---  function user.new(name, age, hobbies)
 ---    vim.validate{
@@ -202,26 +200,29 @@ end
 ---    }
 ---    ...
 ---  end
---
----  vim.validate{ arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
+--- </pre>
+---
+--- Examples with explicit argument values (can be run directly):
+--- <pre>
+---  vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
 ---     => NOP (success)
+---
 ---  vim.validate{arg1={1, 'table'}}
----     => error("arg1: expected table, got number")
----  vim.validate{arg1={{'foo'}, 'table'}, arg2={1, 'string'}}
----     => error("arg2: expected string, got number")
+---     => error('arg1: expected table, got number')
+---
 ---  vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
----     => error("arg1: expected even number, got 3")
+---     => error('arg1: expected even number, got 3')
 --- </pre>
 ---
 --@param opt Map of parameter names to validations. Each key is a parameter
 ---          name; each value is a tuple in one of these forms:
----          1. {arg_value, type_name, optional}
+---          1. (arg_value, type_name, optional)
 ---             - arg_value: argument value
 ---             - type_name: string type name, one of: ("table", "t", "string",
 ---               "s", "number", "n", "boolean", "b", "function", "f", "nil",
 ---               "thread", "userdata")
 ---             - optional: (optional) boolean, if true, `nil` is valid
----          2. {arg_value, fn, msg}
+---          2. (arg_value, fn, msg)
 ---             - arg_value: argument value
 ---             - fn: any function accepting one argument, returns true if and
 ---               only if the argument is valid
@@ -234,14 +235,14 @@ vim.validate = (function()
     ['boolean']='boolean', ['function']='function', ['callable']='callable',
     ['nil']='nil', ['thread']='thread', ['userdata']='userdata',
   }
-  local function type_name(t)
+  local function _type_name(t)
     local tname = type_names[t]
     if tname == nil then
       error(string.format('invalid type name: %s', tostring(t)))
     end
     return tname
   end
-  local function is_type(val, t)
+  local function _is_type(val, t)
     return t == 'callable' and vim.is_callable(val) or type(val) == t
   end
 
@@ -255,21 +256,21 @@ vim.validate = (function()
       local optional = (true == spec[3])
 
       if not vim.is_callable(t) then  -- Check type name.
-        if not (optional or type(val) == 'nil') and not is_type(val, type_name(t)) then
-          error(string.format("%s: expected %s, got %s", param_name, type_name(t), type(val)))
+        if (not optional or val ~= nil) and not _is_type(val, _type_name(t)) then
+          error(string.format("%s: expected %s, got %s", param_name, _type_name(t), type(val)))
         end
       elseif not t(val) then  -- Check user-provided validation function.
-        error(string.format("%s: expected %s, got %s", param_name, spec[3], val))
+        error(string.format("%s: expected %s, got %s", param_name, (spec[3] or '?'), val))
       end
     end
     return true
   end
 end)()
 
---- Return whether an object can call be used as a function.
+--- Returns true if object `f` can be called as a function.
 ---
---@param f Any type of variable
---@return Boolean
+--@param f Any object
+--@return true if `f` is callable, else false
 function vim.is_callable(f)
   if type(f) == 'function' then return true end
   local m = getmetatable(f)
-- 
cgit 


From 00dc12c5d8454a2d3c6806710f63bbb446076e96 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 13 Nov 2019 12:55:26 -0800
Subject: lua LSP client: initial implementation (#11336)

Mainly configuration and RPC infrastructure can be considered "done". Specific requests and their callbacks will be improved later (and also served by plugins). There are also some TODO:s for the client itself, like incremental updates.

Co-authored by at-tjdevries and at-h-michael, with many review/suggestion contributions.
---
 runtime/lua/vim/lsp.lua                   | 1055 +++++++++++++++++++++++++++++
 runtime/lua/vim/lsp/builtin_callbacks.lua |  296 ++++++++
 runtime/lua/vim/lsp/log.lua               |   95 +++
 runtime/lua/vim/lsp/protocol.lua          |  936 +++++++++++++++++++++++++
 runtime/lua/vim/lsp/rpc.lua               |  451 ++++++++++++
 runtime/lua/vim/lsp/util.lua              |  557 +++++++++++++++
 runtime/lua/vim/shared.lua                |  127 +++-
 runtime/lua/vim/uri.lua                   |   89 +++
 8 files changed, 3605 insertions(+), 1 deletion(-)
 create mode 100644 runtime/lua/vim/lsp.lua
 create mode 100644 runtime/lua/vim/lsp/builtin_callbacks.lua
 create mode 100644 runtime/lua/vim/lsp/log.lua
 create mode 100644 runtime/lua/vim/lsp/protocol.lua
 create mode 100644 runtime/lua/vim/lsp/rpc.lua
 create mode 100644 runtime/lua/vim/lsp/util.lua
 create mode 100644 runtime/lua/vim/uri.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
new file mode 100644
index 0000000000..9dbe03dace
--- /dev/null
+++ b/runtime/lua/vim/lsp.lua
@@ -0,0 +1,1055 @@
+local builtin_callbacks = require 'vim.lsp.builtin_callbacks'
+local log = require 'vim.lsp.log'
+local lsp_rpc = require 'vim.lsp.rpc'
+local protocol = require 'vim.lsp.protocol'
+local util = require 'vim.lsp.util'
+
+local nvim_err_writeln, nvim_buf_get_lines, nvim_command, nvim_buf_get_option
+  = vim.api.nvim_err_writeln, vim.api.nvim_buf_get_lines, vim.api.nvim_command, vim.api.nvim_buf_get_option
+local uv = vim.loop
+local tbl_isempty, tbl_extend = vim.tbl_isempty, vim.tbl_extend
+local validate = vim.validate
+
+local lsp = {
+  protocol = protocol;
+  builtin_callbacks = builtin_callbacks;
+  util = util;
+  -- Allow raw RPC access.
+  rpc = lsp_rpc;
+  -- Export these directly from rpc.
+  rpc_response_error = lsp_rpc.rpc_response_error;
+  -- You probably won't need this directly, since __tostring is set for errors
+  -- by the RPC.
+  -- format_rpc_error = lsp_rpc.format_rpc_error;
+}
+
+-- TODO consider whether 'eol' or 'fixeol' should change the nvim_buf_get_lines that send.
+-- TODO improve handling of scratch buffers with LSP attached.
+
+local function resolve_bufnr(bufnr)
+  validate { bufnr = { bufnr, 'n', true } }
+  if bufnr == nil or bufnr == 0 then
+    return vim.api.nvim_get_current_buf()
+  end
+  return bufnr
+end
+
+local function is_dir(filename)
+  validate{filename={filename,'s'}}
+  local stat = uv.fs_stat(filename)
+  return stat and stat.type == 'directory' or false
+end
+
+-- TODO Use vim.wait when that is available, but provide an alternative for now.
+local wait = vim.wait or function(timeout_ms, condition, interval)
+  validate {
+    timeout_ms = { timeout_ms, 'n' };
+    condition = { condition, 'f' };
+    interval = { interval, 'n', true };
+  }
+  assert(timeout_ms > 0, "timeout_ms must be > 0")
+  local _ = log.debug() and log.debug("wait.fallback", timeout_ms)
+  interval = interval or 200
+  local interval_cmd = "sleep "..interval.."m"
+  local timeout = timeout_ms + uv.now()
+  -- TODO is there a better way to sync this?
+  while true do
+    uv.update_time()
+    if condition() then
+      return 0
+    end
+    if uv.now() >= timeout then
+      return -1
+    end
+    nvim_command(interval_cmd)
+    -- vim.loop.sleep(10)
+  end
+end
+local wait_result_reason = { [-1] = "timeout"; [-2] = "interrupted"; [-3] = "error" }
+
+local valid_encodings = {
+  ["utf-8"] = 'utf-8'; ["utf-16"] = 'utf-16'; ["utf-32"] = 'utf-32';
+  ["utf8"]  = 'utf-8'; ["utf16"]  = 'utf-16'; ["utf32"]  = 'utf-32';
+  UTF8      = 'utf-8'; UTF16      = 'utf-16'; UTF32      = 'utf-32';
+}
+
+local client_index = 0
+local function next_client_id()
+  client_index = client_index + 1
+  return client_index
+end
+-- Tracks all clients created via lsp.start_client
+local active_clients = {}
+local all_buffer_active_clients = {}
+local uninitialized_clients = {}
+
+local function for_each_buffer_client(bufnr, callback)
+  validate {
+    callback = { callback, 'f' };
+  }
+  bufnr = resolve_bufnr(bufnr)
+  local client_ids = all_buffer_active_clients[bufnr]
+  if not client_ids or tbl_isempty(client_ids) then
+    return
+  end
+  for client_id in pairs(client_ids) do
+    -- This is unlikely to happen. Could only potentially happen in a race
+    -- condition between literally a single statement.
+    -- We could skip this error, but let's error for now.
+    local client = active_clients[client_id]
+        -- or error(string.format("Client %d has already shut down.", client_id))
+    if client then
+      callback(client, client_id)
+    end
+  end
+end
+
+-- Error codes to be used with `on_error` from |vim.lsp.start_client|.
+-- Can be used to look up the string from a the number or the number
+-- from the string.
+lsp.client_errors = tbl_extend("error", lsp_rpc.client_errors, vim.tbl_add_reverse_lookup {
+  ON_INIT_CALLBACK_ERROR = table.maxn(lsp_rpc.client_errors) + 1;
+})
+
+local function validate_encoding(encoding)
+  validate {
+    encoding = { encoding, 's' };
+  }
+  return valid_encodings[encoding:lower()]
+      or error(string.format("Invalid offset encoding %q. Must be one of: 'utf-8', 'utf-16', 'utf-32'", encoding))
+end
+
+local function validate_command(input)
+  local cmd, cmd_args
+  if type(input) == 'string' then
+    -- Use a shell to execute the command if it is a string.
+    cmd = vim.api.nvim_get_option('shell')
+    cmd_args = {vim.api.nvim_get_option('shellcmdflag'), input}
+  elseif vim.tbl_islist(input) then
+    cmd = input[1]
+    cmd_args = {}
+    -- Don't mutate our input.
+    for i, v in ipairs(input) do
+      assert(type(v) == 'string', "input arguments must be strings")
+      if i > 1 then
+        table.insert(cmd_args, v)
+      end
+    end
+  else
+    error("cmd type must be string or list.")
+  end
+  return cmd, cmd_args
+end
+
+local function optional_validator(fn)
+  return function(v)
+    return v == nil or fn(v)
+  end
+end
+
+local function validate_client_config(config)
+  validate {
+    config = { config, 't' };
+  }
+  validate {
+    root_dir        = { config.root_dir, is_dir, "directory" };
+    callbacks       = { config.callbacks, "t", true };
+    capabilities    = { config.capabilities, "t", true };
+    -- cmd             = { config.cmd, "s", false };
+    cmd_cwd         = { config.cmd_cwd, optional_validator(is_dir), "directory" };
+    cmd_env         = { config.cmd_env, "f", true };
+    name            = { config.name, 's', true };
+    on_error        = { config.on_error, "f", true };
+    on_exit         = { config.on_exit, "f", true };
+    on_init         = { config.on_init, "f", true };
+    offset_encoding = { config.offset_encoding, "s", true };
+  }
+  local cmd, cmd_args = validate_command(config.cmd)
+  local offset_encoding = valid_encodings.UTF16
+  if config.offset_encoding then
+    offset_encoding = validate_encoding(config.offset_encoding)
+  end
+  return {
+    cmd = cmd; cmd_args = cmd_args;
+    offset_encoding = offset_encoding;
+  }
+end
+
+local function text_document_did_open_handler(bufnr, client)
+  if not client.resolved_capabilities.text_document_open_close then
+    return
+  end
+  if not vim.api.nvim_buf_is_loaded(bufnr) then
+    return
+  end
+  local params = {
+    textDocument = {
+      version = 0;
+      uri = vim.uri_from_bufnr(bufnr);
+      -- TODO make sure our filetypes are compatible with languageId names.
+      languageId = nvim_buf_get_option(bufnr, 'filetype');
+      text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, false), '\n');
+    }
+  }
+  client.notify('textDocument/didOpen', params)
+end
+
+
+--- Start a client and initialize it.
+-- Its arguments are passed via a configuration object.
+--
+-- Mandatory parameters:
+--
+-- root_dir: {string} specifying the directory where the LSP server will base
+-- as its rootUri on initialization.
+--
+-- cmd: {string} or {list} which is the base command to execute for the LSP. A
+-- string will be run using |'shell'| and a list will be interpreted as a bare
+-- command with arguments passed. This is the same as |jobstart()|.
+--
+-- Optional parameters:
+
+-- cmd_cwd: {string} specifying the directory to launch the `cmd` process. This
+-- is not related to `root_dir`. By default, |getcwd()| is used.
+--
+-- cmd_env: {table} specifying the environment flags to pass to the LSP on
+-- spawn.  This can be specified using keys like a map or as a list with `k=v`
+-- pairs or both. Non-string values are coerced to a string.
+-- For example: `{ "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; }`.
+--
+-- capabilities: A {table} which will be used instead of
+-- `vim.lsp.protocol.make_client_capabilities()` which contains neovim's
+-- default capabilities and passed to the language server on initialization.
+-- You'll probably want to use make_client_capabilities() and modify the
+-- result.
+-- NOTE:
+--   To send an empty dictionary, you should use
+--   `{[vim.type_idx]=vim.types.dictionary}` Otherwise, it will be encoded as
+--   an array.
+--
+-- callbacks: A {table} of whose keys are language server method names and the
+-- values are `function(err, method, params, client_id)`.
+-- This will be called for:
+-- - notifications from the server, where `err` will always be `nil`
+-- - requests initiated by the server. For these, you can respond by returning
+-- two values: `result, err`. The err must be in the format of an RPC error,
+-- which is `{ code, message, data? }`. You can use |vim.lsp.rpc_response_error()|
+-- to help with this.
+-- - as a callback for requests initiated by the client if the request doesn't
+-- explicitly specify a callback.
+--
+-- init_options: A {table} of values to pass in the initialization request
+-- as `initializationOptions`. See the `initialize` in the LSP spec.
+--
+-- name: A {string} used in log messages. Defaults to {client_id}
+--
+-- offset_encoding: One of 'utf-8', 'utf-16', or 'utf-32' which is the
+-- encoding that the LSP server expects. By default, it is 'utf-16' as
+-- specified in the LSP specification. The client does not verify this
+-- is correct.
+--
+-- on_error(code, ...): A function for handling errors thrown by client
+-- operation. {code} is a number describing the error. Other arguments may be
+-- passed depending on the error kind.  @see |vim.lsp.client_errors| for
+-- possible errors. `vim.lsp.client_errors[code]` can be used to retrieve a
+-- human understandable string.
+--
+-- on_init(client, initialize_result): A function which is called after the
+-- request `initialize` is completed. `initialize_result` contains
+-- `capabilities` and anything else the server may send. For example, `clangd`
+-- sends `result.offsetEncoding` if `capabilities.offsetEncoding` was sent to
+-- it.
+--
+-- on_exit(code, signal, client_id): A function which is called after the
+-- client has exited. code is the exit code of the process, and signal is a
+-- number describing the signal used to terminate (if any).
+--
+-- on_attach(client, bufnr): A function which is called after the client is
+-- attached to a buffer.
+--
+-- trace:  'off' | 'messages' | 'verbose' | nil passed directly to the language
+-- server in the initialize request. Invalid/empty values will default to 'off'
+--
+-- @returns client_id You can use |vim.lsp.get_client_by_id()| to get the
+-- actual client.
+--
+-- NOTE: The client is only available *after* it has been initialized, which
+-- may happen after a small delay (or never if there is an error).
+-- For this reason, you may want to use `on_init` to do any actions once the
+-- client has been initialized.
+function lsp.start_client(config)
+  local cleaned_config = validate_client_config(config)
+  local cmd, cmd_args, offset_encoding = cleaned_config.cmd, cleaned_config.cmd_args, cleaned_config.offset_encoding
+
+  local client_id = next_client_id()
+
+  local callbacks = tbl_extend("keep", config.callbacks or {}, builtin_callbacks)
+  -- Copy metatable if it has one.
+  if config.callbacks and config.callbacks.__metatable then
+    setmetatable(callbacks, getmetatable(config.callbacks))
+  end
+  local name = config.name or tostring(client_id)
+  local log_prefix = string.format("LSP[%s]", name)
+
+  local handlers = {}
+
+  function handlers.notification(method, params)
+    local _ = log.debug() and log.debug('notification', method, params)
+    local callback = callbacks[method]
+    if callback then
+      -- Method name is provided here for convenience.
+      callback(nil, method, params, client_id)
+    end
+  end
+
+  function handlers.server_request(method, params)
+    local _ = log.debug() and log.debug('server_request', method, params)
+    local callback = callbacks[method]
+    if callback then
+      local _ = log.debug() and log.debug("server_request: found callback for", method)
+      return callback(nil, method, params, client_id)
+    end
+    local _ = log.debug() and log.debug("server_request: no callback found for", method)
+    return nil, lsp.rpc_response_error(protocol.ErrorCodes.MethodNotFound)
+  end
+
+  function handlers.on_error(code, err)
+    local _ = log.error() and log.error(log_prefix, "on_error", { code = lsp.client_errors[code], err = err })
+    nvim_err_writeln(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
+    if config.on_error then
+      local status, usererr = pcall(config.on_error, code, err)
+      if not status then
+        local _ = log.error() and log.error(log_prefix, "user on_error failed", { err = usererr })
+        nvim_err_writeln(log_prefix.." user on_error failed: "..tostring(usererr))
+      end
+    end
+  end
+
+  function handlers.on_exit(code, signal)
+    active_clients[client_id] = nil
+    uninitialized_clients[client_id] = nil
+    for _, client_ids in pairs(all_buffer_active_clients) do
+      client_ids[client_id] = nil
+    end
+    if config.on_exit then
+      pcall(config.on_exit, code, signal, client_id)
+    end
+  end
+
+  -- Start the RPC client.
+  local rpc = lsp_rpc.start(cmd, cmd_args, handlers, {
+    cwd = config.cmd_cwd;
+    env = config.cmd_env;
+  })
+
+  local client = {
+    id = client_id;
+    name = name;
+    rpc = rpc;
+    offset_encoding = offset_encoding;
+    callbacks = callbacks;
+    config = config;
+  }
+
+  -- Store the uninitialized_clients for cleanup in case we exit before
+  -- initialize finishes.
+  uninitialized_clients[client_id] = client;
+
+  local function initialize()
+    local valid_traces = {
+      off = 'off'; messages = 'messages'; verbose = 'verbose';
+    }
+    local initialize_params = {
+      -- The process Id of the parent process that started the server. Is null if
+      -- the process has not been started by another process.  If the parent
+      -- process is not alive then the server should exit (see exit notification)
+      -- its process.
+      processId = uv.getpid();
+      -- The rootPath of the workspace. Is null if no folder is open.
+      --
+      -- @deprecated in favour of rootUri.
+      rootPath = nil;
+      -- The rootUri of the workspace. Is null if no folder is open. If both
+      -- `rootPath` and `rootUri` are set `rootUri` wins.
+      rootUri = vim.uri_from_fname(config.root_dir);
+--      rootUri = vim.uri_from_fname(vim.fn.expand("%:p:h"));
+      -- User provided initialization options.
+      initializationOptions = config.init_options;
+      -- The capabilities provided by the client (editor or tool)
+      capabilities = config.capabilities or protocol.make_client_capabilities();
+      -- The initial trace setting. If omitted trace is disabled ('off').
+      -- trace = 'off' | 'messages' | 'verbose';
+      trace = valid_traces[config.trace] or 'off';
+      -- The workspace folders configured in the client when the server starts.
+      -- This property is only available if the client supports workspace folders.
+      -- It can be `null` if the client supports workspace folders but none are
+      -- configured.
+      --
+      -- Since 3.6.0
+      -- workspaceFolders?: WorkspaceFolder[] | null;
+      -- export interface WorkspaceFolder {
+      --  -- The associated URI for this workspace folder.
+      --  uri
+      --  -- The name of the workspace folder. Used to refer to this
+      --  -- workspace folder in the user interface.
+      --  name
+      -- }
+      workspaceFolders = nil;
+    }
+    local _ = log.debug() and log.debug(log_prefix, "initialize_params", initialize_params)
+    rpc.request('initialize', initialize_params, function(init_err, result)
+      assert(not init_err, tostring(init_err))
+      assert(result, "server sent empty result")
+      rpc.notify('initialized', {})
+      client.initialized = true
+      uninitialized_clients[client_id] = nil
+      client.server_capabilities = assert(result.capabilities, "initialize result doesn't contain capabilities")
+      -- These are the cleaned up capabilities we use for dynamically deciding
+      -- when to send certain events to clients.
+      client.resolved_capabilities = protocol.resolve_capabilities(client.server_capabilities)
+      if config.on_init then
+        local status, err = pcall(config.on_init, client, result)
+        if not status then
+          pcall(handlers.on_error, lsp.client_errors.ON_INIT_CALLBACK_ERROR, err)
+        end
+      end
+      local _ = log.debug() and log.debug(log_prefix, "server_capabilities", client.server_capabilities)
+      local _ = log.info() and log.info(log_prefix, "initialized", { resolved_capabilities = client.resolved_capabilities })
+
+      -- Only assign after initialized.
+      active_clients[client_id] = client
+      -- If we had been registered before we start, then send didOpen This can
+      -- happen if we attach to buffers before initialize finishes or if
+      -- someone restarts a client.
+      for bufnr, client_ids in pairs(all_buffer_active_clients) do
+        if client_ids[client_id] then
+          client._on_attach(bufnr)
+        end
+      end
+    end)
+  end
+
+  local function unsupported_method(method)
+    local msg = "server doesn't support "..method
+    local _ = log.warn() and log.warn(msg)
+    nvim_err_writeln(msg)
+    return lsp.rpc_response_error(protocol.ErrorCodes.MethodNotFound, msg)
+  end
+
+  --- Checks capabilities before rpc.request-ing.
+  function client.request(method, params, callback)
+    if not callback then
+      callback = client.callbacks[method]
+        or error(string.format("request callback is empty and no default was found for client %s", client.name))
+    end
+    local _ = log.debug() and log.debug(log_prefix, "client.request", client_id, method, params, callback)
+    -- TODO keep these checks or just let it go anyway?
+    if (not client.resolved_capabilities.hover and method == 'textDocument/hover')
+      or (not client.resolved_capabilities.signature_help and method == 'textDocument/signatureHelp')
+      or (not client.resolved_capabilities.goto_definition and method == 'textDocument/definition')
+      or (not client.resolved_capabilities.implementation and method == 'textDocument/implementation')
+    then
+      callback(unsupported_method(method), method, nil, client_id)
+      return
+    end
+    return rpc.request(method, params, function(err, result)
+      callback(err, method, result, client_id)
+    end)
+  end
+
+  function client.notify(...)
+    return rpc.notify(...)
+  end
+
+  function client.cancel_request(id)
+    validate{id = {id, 'n'}}
+    return rpc.notify("$/cancelRequest", { id = id })
+  end
+
+  -- Track this so that we can escalate automatically if we've alredy tried a
+  -- graceful shutdown
+  local tried_graceful_shutdown = false
+  function client.stop(force)
+    local handle = rpc.handle
+    if handle:is_closing() then
+      return
+    end
+    if force or (not client.initialized) or tried_graceful_shutdown then
+      handle:kill(15)
+      return
+    end
+    tried_graceful_shutdown = true
+    -- Sending a signal after a process has exited is acceptable.
+    rpc.request('shutdown', nil, function(err, _)
+      if err == nil then
+        rpc.notify('exit')
+      else
+        -- If there was an error in the shutdown request, then term to be safe.
+        handle:kill(15)
+      end
+    end)
+  end
+
+  function client.is_stopped()
+    return rpc.handle:is_closing()
+  end
+
+  function client._on_attach(bufnr)
+    text_document_did_open_handler(bufnr, client)
+    if config.on_attach then
+      -- TODO(ashkan) handle errors.
+      pcall(config.on_attach, client, bufnr)
+    end
+  end
+
+  initialize()
+
+  return client_id
+end
+
+local function once(fn)
+  local value
+  return function(...)
+    if not value then value = fn(...) end
+    return value
+  end
+end
+
+local text_document_did_change_handler
+do
+  local encoding_index = { ["utf-8"] = 1; ["utf-16"] = 2; ["utf-32"] = 3; }
+  text_document_did_change_handler = function(_, bufnr, changedtick,
+      firstline, lastline, new_lastline, old_byte_size, old_utf32_size,
+      old_utf16_size)
+    local _ = log.debug() and log.debug("on_lines", bufnr, changedtick, firstline,
+    lastline, new_lastline, old_byte_size, old_utf32_size, old_utf16_size, nvim_buf_get_lines(bufnr, firstline, new_lastline, true))
+    if old_byte_size == 0 then
+      return
+    end
+    -- Don't do anything if there are no clients attached.
+    if tbl_isempty(all_buffer_active_clients[bufnr] or {}) then
+      return
+    end
+    -- Lazy initialize these because clients may not even need them.
+    local incremental_changes = once(function(client)
+      local size_index = encoding_index[client.offset_encoding]
+      local length = select(size_index, old_byte_size, old_utf16_size, old_utf32_size)
+      local lines = nvim_buf_get_lines(bufnr, firstline, new_lastline, true)
+      -- This is necessary because we are specifying the full line including the
+      -- newline in range. Therefore, we must replace the newline as well.
+      if #lines > 0 then
+       table.insert(lines, '')
+      end
+      return {
+        range = {
+          start = { line = firstline, character = 0 };
+          ["end"] = { line = lastline, character = 0 };
+        };
+        rangeLength = length;
+        text = table.concat(lines, '\n');
+      };
+    end)
+    local full_changes = once(function()
+      return {
+        text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, false), "\n");
+      };
+    end)
+    local uri = vim.uri_from_bufnr(bufnr)
+    for_each_buffer_client(bufnr, function(client, _client_id)
+      local text_document_did_change = client.resolved_capabilities.text_document_did_change
+      local changes
+      if text_document_did_change == protocol.TextDocumentSyncKind.None then
+        return
+      --[=[ TODO(ashkan) there seem to be problems with the byte_sizes sent by
+      -- neovim right now so only send the full content for now. In general, we
+      -- can assume that servers *will* support both versions anyway, as there
+      -- is no way to specify the sync capability by the client.
+      -- See https://github.com/palantir/python-language-server/commit/cfd6675bc10d5e8dbc50fc50f90e4a37b7178821#diff-f68667852a14e9f761f6ebf07ba02fc8 for an example of pyls handling both.
+      --]=]
+      elseif true or text_document_did_change == protocol.TextDocumentSyncKind.Full then
+        changes = full_changes(client)
+      elseif text_document_did_change == protocol.TextDocumentSyncKind.Incremental then
+        changes = incremental_changes(client)
+      end
+      client.notify("textDocument/didChange", {
+        textDocument = {
+          uri = uri;
+          version = changedtick;
+        };
+        contentChanges = { changes; }
+      })
+    end)
+  end
+end
+
+-- Buffer lifecycle handler for textDocument/didSave
+function lsp._text_document_did_save_handler(bufnr)
+  bufnr = resolve_bufnr(bufnr)
+  local uri = vim.uri_from_bufnr(bufnr)
+  local text = once(function()
+    return table.concat(nvim_buf_get_lines(bufnr, 0, -1, false), '\n')
+  end)
+  for_each_buffer_client(bufnr, function(client, _client_id)
+    if client.resolved_capabilities.text_document_save then
+      local included_text
+      if client.resolved_capabilities.text_document_save_include_text then
+        included_text = text()
+      end
+      client.notify('textDocument/didSave', {
+        textDocument = {
+          uri = uri;
+          text = included_text;
+        }
+      })
+    end
+  end)
+end
+
+-- Implements the textDocument/did* notifications required to track a buffer
+-- for any language server.
+-- @param bufnr [number] buffer handle or 0 for current
+-- @param client_id [number] the client id
+function lsp.buf_attach_client(bufnr, client_id)
+  validate {
+    bufnr     = {bufnr, 'n', true};
+    client_id = {client_id, 'n'};
+  }
+  bufnr = resolve_bufnr(bufnr)
+  local buffer_client_ids = all_buffer_active_clients[bufnr]
+  -- This is our first time attaching to this buffer.
+  if not buffer_client_ids then
+    buffer_client_ids = {}
+    all_buffer_active_clients[bufnr] = buffer_client_ids
+
+    local uri = vim.uri_from_bufnr(bufnr)
+    nvim_command(string.format("autocmd BufWritePost <buffer=%d> lua vim.lsp._text_document_did_save_handler(0)", bufnr))
+    -- First time, so attach and set up stuff.
+    vim.api.nvim_buf_attach(bufnr, false, {
+      on_lines = text_document_did_change_handler;
+      on_detach = function()
+        local params = { textDocument = { uri = uri; } }
+        for_each_buffer_client(bufnr, function(client, _client_id)
+          if client.resolved_capabilities.text_document_open_close then
+            client.notify('textDocument/didClose', params)
+          end
+        end)
+        all_buffer_active_clients[bufnr] = nil
+      end;
+      -- TODO if we know all of the potential clients ahead of time, then we
+      -- could conditionally set this.
+      --      utf_sizes = size_index > 1;
+      utf_sizes = true;
+    })
+  end
+  if buffer_client_ids[client_id] then return end
+  -- This is our first time attaching this client to this buffer.
+  buffer_client_ids[client_id] = true
+
+  local client = active_clients[client_id]
+  -- Send didOpen for the client if it is initialized. If it isn't initialized
+  -- then it will send didOpen on initialize.
+  if client then
+    client._on_attach(bufnr)
+  end
+  return true
+end
+
+-- Check if a buffer is attached for a particular client.
+-- @param bufnr [number] buffer handle or 0 for current
+-- @param client_id [number] the client id
+function lsp.buf_is_attached(bufnr, client_id)
+  return (all_buffer_active_clients[bufnr] or {})[client_id] == true
+end
+
+-- Look up an active client by its id, returns nil if it is not yet initialized
+-- or is not a valid id.
+-- @param client_id number the client id.
+function lsp.get_client_by_id(client_id)
+  return active_clients[client_id]
+end
+
+-- Stop a client by its id, optionally with force.
+-- You can also use the `stop()` function on a client if you already have
+-- access to it.
+-- By default, it will just ask the server to shutdown without force.
+-- If you request to stop a client which has previously been requested to shutdown,
+-- it will automatically force shutdown.
+-- @param client_id number the client id.
+-- @param force boolean (optional) whether to use force or request shutdown
+function lsp.stop_client(client_id, force)
+  local client
+  client = active_clients[client_id]
+  if client then
+    client.stop(force)
+    return
+  end
+  client = uninitialized_clients[client_id]
+  if client then
+    client.stop(true)
+  end
+end
+
+-- Returns a list of all the active clients.
+function lsp.get_active_clients()
+  return vim.tbl_values(active_clients)
+end
+
+-- Stop all the clients, optionally with force.
+-- You can also use the `stop()` function on a client if you already have
+-- access to it.
+-- By default, it will just ask the server to shutdown without force.
+-- If you request to stop a client which has previously been requested to shutdown,
+-- it will automatically force shutdown.
+-- @param force boolean (optional) whether to use force or request shutdown
+function lsp.stop_all_clients(force)
+  for _, client in pairs(uninitialized_clients) do
+    client.stop(true)
+  end
+  for _, client in pairs(active_clients) do
+    client.stop(force)
+  end
+end
+
+function lsp._vim_exit_handler()
+  log.info("exit_handler", active_clients)
+  for _, client in pairs(uninitialized_clients) do
+    client.stop(true)
+  end
+  -- TODO handle v:dying differently?
+  if tbl_isempty(active_clients) then
+    return
+  end
+  for _, client in pairs(active_clients) do
+    client.stop()
+  end
+  local wait_result = wait(500, function() return tbl_isempty(active_clients) end, 50)
+  if wait_result ~= 0 then
+    for _, client in pairs(active_clients) do
+      client.stop(true)
+    end
+  end
+end
+
+nvim_command("autocmd VimLeavePre * lua vim.lsp._vim_exit_handler()")
+
+---
+--- Buffer level client functions.
+---
+
+--- Send a request to a server and return the response
+-- @param bufnr [number] Buffer handle or 0 for current.
+-- @param method [string] Request method name
+-- @param params [table|nil] Parameters to send to the server
+-- @param callback [function|nil] Request callback (or uses the client's callbacks)
+--
+-- @returns: client_request_ids, cancel_all_requests
+function lsp.buf_request(bufnr, method, params, callback)
+  validate {
+    bufnr    = { bufnr, 'n', true };
+    method   = { method, 's' };
+    callback = { callback, 'f', true };
+  }
+  local client_request_ids = {}
+  for_each_buffer_client(bufnr, function(client, client_id)
+    local request_success, request_id = client.request(method, params, callback)
+
+    -- This could only fail if the client shut down in the time since we looked
+    -- it up and we did the request, which should be rare.
+    if request_success then
+      client_request_ids[client_id] = request_id
+    end
+  end)
+
+  local function cancel_all_requests()
+    for client_id, request_id in pairs(client_request_ids) do
+      local client = active_clients[client_id]
+      client.cancel_request(request_id)
+    end
+  end
+
+  return client_request_ids, cancel_all_requests
+end
+
+--- Send a request to a server and wait for the response.
+-- @param bufnr [number] Buffer handle or 0 for current.
+-- @param method [string] Request method name
+-- @param params [string] Parameters to send to the server
+-- @param timeout_ms [number|100] Maximum ms to wait for a result
+--
+-- @returns: The table of {[client_id] = request_result}
+function lsp.buf_request_sync(bufnr, method, params, timeout_ms)
+  local request_results = {}
+  local result_count = 0
+  local function callback(err, _method, result, client_id)
+    request_results[client_id] = { error = err, result = result }
+    result_count = result_count + 1
+  end
+  local client_request_ids, cancel = lsp.buf_request(bufnr, method, params, callback)
+  local expected_result_count = 0
+  for _ in pairs(client_request_ids) do
+    expected_result_count = expected_result_count + 1
+  end
+  local wait_result = wait(timeout_ms or 100, function()
+    return result_count >= expected_result_count
+  end, 10)
+  if wait_result ~= 0 then
+    cancel()
+    return nil, wait_result_reason[wait_result]
+  end
+  return request_results
+end
+
+--- Send a notification to a server
+-- @param bufnr [number] (optional): The number of the buffer
+-- @param method [string]: Name of the request method
+-- @param params [string]: Arguments to send to the server
+--
+-- @returns nil
+function lsp.buf_notify(bufnr, method, params)
+  validate {
+    bufnr    = { bufnr, 'n', true };
+    method   = { method, 's' };
+  }
+  for_each_buffer_client(bufnr, function(client, _client_id)
+    client.rpc.notify(method, params)
+  end)
+end
+
+--- Function which can be called to generate omnifunc compatible completion.
+function lsp.omnifunc(findstart, base)
+  local _ = log.debug() and log.debug("omnifunc.findstart", { findstart = findstart, base = base })
+
+  local bufnr = resolve_bufnr()
+  local has_buffer_clients = not tbl_isempty(all_buffer_active_clients[bufnr] or {})
+  if not has_buffer_clients then
+    if findstart == 1 then
+      return -1
+    else
+      return {}
+    end
+  end
+
+  if findstart == 1 then
+    return vim.fn.col('.')
+  else
+    local pos = vim.api.nvim_win_get_cursor(0)
+    local line = assert(nvim_buf_get_lines(bufnr, pos[1]-1, pos[1], false)[1])
+    local _ = log.trace() and log.trace("omnifunc.line", pos, line)
+    local line_to_cursor = line:sub(1, pos[2]+1)
+    local _ = log.trace() and log.trace("omnifunc.line_to_cursor", line_to_cursor)
+    local params = {
+      textDocument = {
+        uri = vim.uri_from_bufnr(bufnr);
+      };
+      position = {
+        -- 0-indexed for both line and character
+        line = pos[1] - 1,
+        character = pos[2],
+      };
+      -- The completion context. This is only available if the client specifies
+      -- to send this using `ClientCapabilities.textDocument.completion.contextSupport === true`
+      -- context = nil or {
+      --  triggerKind = protocol.CompletionTriggerKind.Invoked;
+      --  triggerCharacter = nil or "";
+      -- };
+    }
+    -- TODO handle timeout error differently? Like via an error?
+    local client_responses = lsp.buf_request_sync(bufnr, 'textDocument/completion', params) or {}
+    local matches = {}
+    for _, response in pairs(client_responses) do
+      -- TODO how to handle errors?
+      if not response.error then
+        local data = response.result
+        local completion_items = util.text_document_completion_list_to_complete_items(data or {}, line_to_cursor)
+        local _ = log.trace() and log.trace("omnifunc.completion_items", completion_items)
+        vim.list_extend(matches, completion_items)
+      end
+    end
+    return matches
+  end
+end
+
+---
+--- FileType based configuration utility
+---
+
+local all_filetype_configs = {}
+
+-- Lookup a filetype config client by its name.
+function lsp.get_filetype_client_by_name(name)
+  local config = all_filetype_configs[name]
+  if config.client_id then
+    return active_clients[config.client_id]
+  end
+end
+
+local function start_filetype_config(config)
+  config.client_id = lsp.start_client(config)
+  nvim_command(string.format(
+    "autocmd FileType %s silent lua vim.lsp.buf_attach_client(0, %d)",
+    table.concat(config.filetypes, ','),
+    config.client_id))
+  return config.client_id
+end
+
+-- Easy configuration option for common LSP use-cases.
+-- This will lazy initialize the client when the filetypes specified are
+-- encountered and attach to those buffers.
+--
+-- The configuration options are the same as |vim.lsp.start_client()|, but
+-- with a few additions and distinctions:
+--
+-- Additional parameters:
+-- - filetype: {string} or {list} of filetypes to attach to.
+-- - name: A unique string among all other servers configured with
+-- |vim.lsp.add_filetype_config|.
+--
+-- Differences:
+-- - root_dir: will default to |getcwd()|
+--
+function lsp.add_filetype_config(config)
+  -- Additional defaults.
+  -- Keep a copy of the user's input for debugging reasons.
+  local user_config = config
+  config = tbl_extend("force", {}, user_config)
+  config.root_dir = config.root_dir or uv.cwd()
+  -- Validate config.
+  validate_client_config(config)
+  validate {
+    name = { config.name, 's' };
+  }
+  assert(config.filetype, "config must have 'filetype' key")
+
+  local filetypes
+  if type(config.filetype) == 'string' then
+    filetypes = { config.filetype }
+  elseif type(config.filetype) == 'table' then
+    filetypes = config.filetype
+    assert(not tbl_isempty(filetypes), "config.filetype must not be an empty table")
+  else
+    error("config.filetype must be a string or a list of strings")
+  end
+
+  if all_filetype_configs[config.name] then
+    -- If the client exists, then it is likely that they are doing some kind of
+    -- reload flow, so let's not throw an error here.
+    if all_filetype_configs[config.name].client_id then
+      -- TODO log here? It might be unnecessarily annoying.
+      return
+    end
+    error(string.format('A configuration with the name %q already exists. They must be unique', config.name))
+  end
+
+  all_filetype_configs[config.name] = tbl_extend("keep", config, {
+    client_id = nil;
+    filetypes = filetypes;
+    user_config = user_config;
+  })
+
+  nvim_command(string.format(
+    "autocmd FileType %s ++once silent lua vim.lsp._start_filetype_config_client(%q)",
+    table.concat(filetypes, ','),
+    config.name))
+end
+
+-- Create a copy of an existing configuration, and override config with values
+-- from new_config.
+-- This is useful if you wish you create multiple LSPs with different root_dirs
+-- or other use cases.
+--
+-- You can specify a new unique name, but if you do not, a unique name will be
+-- created like `name-dup_count`.
+--
+-- existing_name: the name of the existing config to copy.
+-- new_config: the new configuration options. @see |vim.lsp.start_client()|.
+-- @returns string the new name.
+function lsp.copy_filetype_config(existing_name, new_config)
+  local config = all_filetype_configs[existing_name]
+      or error(string.format("Configuration with name %q doesn't exist", existing_name))
+  config = tbl_extend("force", config, new_config or {})
+  config.client_id = nil
+  config.original_config_name = existing_name
+
+  -- If the user didn't rename it, we will.
+  if config.name == existing_name then
+    -- Create a new, unique name.
+    local duplicate_count = 0
+    for _, conf in pairs(all_filetype_configs) do
+      if conf.original_config_name == existing_name then
+        duplicate_count = duplicate_count + 1
+      end
+    end
+    config.name = string.format("%s-%d", existing_name, duplicate_count + 1)
+  end
+  print("New config name:", config.name)
+  lsp.add_filetype_config(config)
+  return config.name
+end
+
+-- Autocmd handler to actually start the client when an applicable filetype is
+-- encountered.
+function lsp._start_filetype_config_client(name)
+  local config = all_filetype_configs[name]
+  -- If it exists and is running, don't make it again.
+  if config.client_id and active_clients[config.client_id] then
+    -- TODO log here?
+    return
+  end
+  lsp.buf_attach_client(0, start_filetype_config(config))
+  return config.client_id
+end
+
+---
+--- Miscellaneous utilities.
+---
+
+-- Retrieve a map from client_id to client of all active buffer clients.
+-- @param bufnr [number] (optional): buffer handle or 0 for current
+function lsp.buf_get_clients(bufnr)
+  bufnr = resolve_bufnr(bufnr)
+ local result = {}
+ for_each_buffer_client(bufnr, function(client, client_id)
+   result[client_id] = client
+ end)
+ return result
+end
+
+-- Print some debug information about the current buffer clients.
+-- The output of this function should not be relied upon and may change.
+function lsp.buf_print_debug_info(bufnr)
+  print(vim.inspect(lsp.buf_get_clients(bufnr)))
+end
+
+-- Print some debug information about all LSP related things.
+-- The output of this function should not be relied upon and may change.
+function lsp.print_debug_info()
+  print(vim.inspect({ clients = active_clients, filetype_configs = all_filetype_configs }))
+end
+
+-- Log level dictionary with reverse lookup as well.
+--
+-- Can be used to lookup the number from the name or the
+-- name from the number.
+-- Levels by name: 'trace', 'debug', 'info', 'warn', 'error'
+-- Level numbers begin with 'trace' at 0
+lsp.log_levels = log.levels
+
+-- Set the log level for lsp logging.
+-- Levels by name: 'trace', 'debug', 'info', 'warn', 'error'
+-- Level numbers begin with 'trace' at 0
+-- @param level [number|string] the case insensitive level name or number @see |vim.lsp.log_levels|
+function lsp.set_log_level(level)
+  if type(level) == 'string' or type(level) == 'number' then
+    log.set_level(level)
+  else
+    error(string.format("Invalid log level: %q", level))
+  end
+end
+
+-- Return the path of the logfile used by the LSP client.
+function lsp.get_log_path()
+  return log.get_filename()
+end
+
+return lsp
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/builtin_callbacks.lua b/runtime/lua/vim/lsp/builtin_callbacks.lua
new file mode 100644
index 0000000000..cc739ce3ad
--- /dev/null
+++ b/runtime/lua/vim/lsp/builtin_callbacks.lua
@@ -0,0 +1,296 @@
+--- Implements the following default callbacks:
+--
+-- vim.api.nvim_buf_set_lines(0, 0, 0, false, vim.tbl_keys(vim.lsp.builtin_callbacks))
+--
+
+-- textDocument/completion
+-- textDocument/declaration
+-- textDocument/definition
+-- textDocument/hover
+-- textDocument/implementation
+-- textDocument/publishDiagnostics
+-- textDocument/rename
+-- textDocument/signatureHelp
+-- textDocument/typeDefinition
+-- TODO codeLens/resolve
+-- TODO completionItem/resolve
+-- TODO documentLink/resolve
+-- TODO textDocument/codeAction
+-- TODO textDocument/codeLens
+-- TODO textDocument/documentHighlight
+-- TODO textDocument/documentLink
+-- TODO textDocument/documentSymbol
+-- TODO textDocument/formatting
+-- TODO textDocument/onTypeFormatting
+-- TODO textDocument/rangeFormatting
+-- TODO textDocument/references
+-- window/logMessage
+-- window/showMessage
+
+local log = require 'vim.lsp.log'
+local protocol = require 'vim.lsp.protocol'
+local util = require 'vim.lsp.util'
+local api = vim.api
+
+local function split_lines(value)
+  return vim.split(value, '\n', true)
+end
+
+local builtin_callbacks = {}
+
+-- textDocument/completion
+-- https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
+builtin_callbacks['textDocument/completion'] = function(_, _, result)
+  if not result or vim.tbl_isempty(result) then
+    return
+  end
+  local pos = api.nvim_win_get_cursor(0)
+  local row, col = pos[1], pos[2]
+  local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
+  local line_to_cursor = line:sub(col+1)
+
+  local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
+  local match_result = vim.fn.matchstrpos(line_to_cursor, '\\k\\+$')
+  local match_start, match_finish = match_result[2], match_result[3]
+
+  vim.fn.complete(col + 1 - (match_finish - match_start), matches)
+end
+
+-- textDocument/rename
+builtin_callbacks['textDocument/rename'] = function(_, _, result)
+  if not result then return end
+  util.workspace_apply_workspace_edit(result)
+end
+
+local function uri_to_bufnr(uri)
+  return vim.fn.bufadd((vim.uri_to_fname(uri)))
+end
+
+builtin_callbacks['textDocument/publishDiagnostics'] = function(_, _, result)
+  if not result then return end
+  local uri = result.uri
+  local bufnr = uri_to_bufnr(uri)
+  if not bufnr then
+    api.nvim_err_writeln(string.format("LSP.publishDiagnostics: Couldn't find buffer for %s", uri))
+    return
+  end
+  util.buf_clear_diagnostics(bufnr)
+  util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
+  util.buf_diagnostics_underline(bufnr, result.diagnostics)
+  util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
+  -- util.buf_loclist(bufnr, result.diagnostics)
+end
+
+-- textDocument/hover
+-- https://microsoft.github.io/language-server-protocol/specification#textDocument_hover
+-- @params MarkedString | MarkedString[] | MarkupContent
+builtin_callbacks['textDocument/hover'] = function(_, _, result)
+  if result == nil or vim.tbl_isempty(result) then
+    return
+  end
+
+  if result.contents ~= nil then
+    local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+    if vim.tbl_isempty(markdown_lines) then
+      markdown_lines = { 'No information available' }
+    end
+    util.open_floating_preview(markdown_lines, 'markdown')
+  end
+end
+
+builtin_callbacks['textDocument/peekDefinition'] = function(_, _, result)
+  if result == nil or vim.tbl_isempty(result) then return end
+  -- TODO(ashkan) what to do with multiple locations?
+  result = result[1]
+  local bufnr = uri_to_bufnr(result.uri)
+  assert(bufnr)
+  local start = result.range.start
+  local finish = result.range["end"]
+  util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
+  util.open_floating_preview({"*Peek:*", string.rep(" ", finish.character - start.character + 1) }, 'markdown', { offset_y = -(finish.line - start.line) })
+end
+
+--- Convert SignatureHelp response to preview contents.
+-- https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_signatureHelp
+local function signature_help_to_preview_contents(input)
+  if not input.signatures then
+    return
+  end
+  --The active signature. If omitted or the value lies outside the range of
+  --`signatures` the value defaults to zero or is ignored if `signatures.length
+  --=== 0`. Whenever possible implementors should make an active decision about
+  --the active signature and shouldn't rely on a default value.
+  local contents = {}
+  local active_signature = input.activeSignature or 0
+  -- If the activeSignature is not inside the valid range, then clip it.
+  if active_signature >= #input.signatures then
+    active_signature = 0
+  end
+  local signature = input.signatures[active_signature + 1]
+  if not signature then
+    return
+  end
+  vim.list_extend(contents, split_lines(signature.label))
+  if signature.documentation then
+    util.convert_input_to_markdown_lines(signature.documentation, contents)
+  end
+  if input.parameters then
+    local active_parameter = input.activeParameter or 0
+    -- If the activeParameter is not inside the valid range, then clip it.
+    if active_parameter >= #input.parameters then
+      active_parameter = 0
+    end
+    local parameter = signature.parameters and signature.parameters[active_parameter]
+    if parameter then
+      --[=[
+      --Represents a parameter of a callable-signature. A parameter can
+      --have a label and a doc-comment.
+      interface ParameterInformation {
+        --The label of this parameter information.
+        --
+        --Either a string or an inclusive start and exclusive end offsets within its containing
+        --signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
+        --string representation as `Position` and `Range` does.
+        --
+        --*Note*: a label of type string should be a substring of its containing signature label.
+        --Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+        label: string | [number, number];
+        --The human-readable doc-comment of this parameter. Will be shown
+        --in the UI but can be omitted.
+        documentation?: string | MarkupContent;
+      }
+      --]=]
+      -- TODO highlight parameter
+      if parameter.documentation then
+        util.convert_input_to_markdown_lines(parameter.documentation, contents)
+      end
+    end
+  end
+  return contents
+end
+
+-- textDocument/signatureHelp
+-- https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp
+builtin_callbacks['textDocument/signatureHelp'] = function(_, _, result)
+  if result == nil or vim.tbl_isempty(result) then
+    return
+  end
+
+  -- TODO show empty popup when signatures is empty?
+  if #result.signatures > 0 then
+    local markdown_lines = signature_help_to_preview_contents(result)
+    if vim.tbl_isempty(markdown_lines) then
+      markdown_lines = { 'No signature available' }
+    end
+    util.open_floating_preview(markdown_lines, 'markdown')
+  end
+end
+
+local function update_tagstack()
+  local bufnr = api.nvim_get_current_buf()
+  local line = vim.fn.line('.')
+  local col = vim.fn.col('.')
+  local tagname = vim.fn.expand('<cWORD>')
+  local item = { bufnr = bufnr, from = { bufnr, line, col, 0 }, tagname = tagname }
+  local winid = vim.fn.win_getid()
+  local tagstack = vim.fn.gettagstack(winid)
+
+  local action
+
+  if tagstack.length == tagstack.curidx then
+    action = 'r'
+    tagstack.items[tagstack.curidx] = item
+  elseif tagstack.length > tagstack.curidx then
+    action = 'r'
+    if tagstack.curidx > 1 then
+      tagstack.items = table.insert(tagstack.items[tagstack.curidx - 1], item)
+    else
+      tagstack.items = { item }
+    end
+  else
+    action = 'a'
+    tagstack.items = { item }
+  end
+
+  tagstack.curidx = tagstack.curidx + 1
+  vim.fn.settagstack(winid, tagstack, action)
+end
+
+local function handle_location(result)
+  -- We can sometimes get a list of locations, so set the first value as the
+  -- only value we want to handle
+  -- TODO(ashkan) was this correct^? We could use location lists.
+  if result[1] ~= nil then
+    result = result[1]
+  end
+  if result.uri == nil then
+    api.nvim_err_writeln('[LSP] Could not find a valid location')
+    return
+  end
+  local result_file = vim.uri_to_fname(result.uri)
+  local bufnr = vim.fn.bufadd(result_file)
+  update_tagstack()
+  api.nvim_set_current_buf(bufnr)
+  local start = result.range.start
+  api.nvim_win_set_cursor(0, {start.line + 1, start.character})
+end
+
+local function location_callback(_, method, result)
+  if result == nil or vim.tbl_isempty(result) then
+    local _ = log.info() and log.info(method, 'No location found')
+    return nil
+  end
+  handle_location(result)
+  return true
+end
+
+local location_callbacks = {
+  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_declaration
+  'textDocument/declaration';
+  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_definition
+  'textDocument/definition';
+  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_implementation
+  'textDocument/implementation';
+  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_typeDefinition
+  'textDocument/typeDefinition';
+}
+
+for _, location_method in ipairs(location_callbacks) do
+  builtin_callbacks[location_method] = location_callback
+end
+
+local function log_message(_, _, result, client_id)
+  local message_type = result.type
+  local message = result.message
+  local client = vim.lsp.get_client_by_id(client_id)
+  local client_name = client and client.name or string.format("id=%d", client_id)
+  if not client then
+    api.nvim_err_writeln(string.format("LSP[%s] client has shut down after sending the message", client_name))
+  end
+  if message_type == protocol.MessageType.Error then
+    -- Might want to not use err_writeln,
+    -- but displaying a message with red highlights or something
+    api.nvim_err_writeln(string.format("LSP[%s] %s", client_name, message))
+  else
+    local message_type_name = protocol.MessageType[message_type]
+    api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
+  end
+  return result
+end
+
+builtin_callbacks['window/showMessage'] = log_message
+builtin_callbacks['window/logMessage'] = log_message
+
+-- Add boilerplate error validation and logging for all of these.
+for k, fn in pairs(builtin_callbacks) do
+  builtin_callbacks[k] = function(err, method, params, client_id)
+    local _ = log.debug() and log.debug('builtin_callback', method, { params = params, client_id = client_id, err = err })
+    if err then
+      error(tostring(err))
+    end
+    return fn(err, method, params, client_id)
+  end
+end
+
+return builtin_callbacks
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/log.lua b/runtime/lua/vim/lsp/log.lua
new file mode 100644
index 0000000000..974eaae38c
--- /dev/null
+++ b/runtime/lua/vim/lsp/log.lua
@@ -0,0 +1,95 @@
+-- Logger for language client plugin.
+
+local log = {}
+
+-- Log level dictionary with reverse lookup as well.
+--
+-- Can be used to lookup the number from the name or the name from the number.
+-- Levels by name: 'trace', 'debug', 'info', 'warn', 'error'
+-- Level numbers begin with 'trace' at 0
+log.levels = {
+  TRACE = 0;
+  DEBUG = 1;
+  INFO  = 2;
+  WARN  = 3;
+  ERROR = 4;
+  -- FATAL = 4;
+}
+
+-- Default log level is warn.
+local current_log_level = log.levels.WARN
+local log_date_format = "%FT%H:%M:%SZ%z"
+
+do
+  local path_sep = vim.loop.os_uname().sysname == "Windows" and "\\" or "/"
+  local function path_join(...)
+    return table.concat(vim.tbl_flatten{...}, path_sep)
+  end
+  local logfilename = path_join(vim.fn.stdpath('data'), 'vim-lsp.log')
+
+  --- Return the log filename.
+  function log.get_filename()
+    return logfilename
+  end
+
+  vim.fn.mkdir(vim.fn.stdpath('data'), "p")
+  local logfile = assert(io.open(logfilename, "a+"))
+  for level, levelnr in pairs(log.levels) do
+    -- Also export the log level on the root object.
+    log[level] = levelnr
+    -- Set the lowercase name as the main use function.
+    -- If called without arguments, it will check whether the log level is
+    -- greater than or equal to this one. When called with arguments, it will
+    -- log at that level (if applicable, it is checked either way).
+    --
+    -- Recommended usage:
+    -- ```
+    -- local _ = log.warn() and log.warn("123")
+    -- ```
+    --
+    -- This way you can avoid string allocations if the log level isn't high enough.
+    log[level:lower()] = function(...)
+      local argc = select("#", ...)
+      if levelnr < current_log_level then return false end
+      if argc == 0 then return true end
+      local info = debug.getinfo(2, "Sl")
+      local fileinfo = string.format("%s:%s", info.short_src, info.currentline)
+      local parts = { table.concat({"[", level, "]", os.date(log_date_format), "]", fileinfo, "]"}, " ") }
+      for i = 1, argc do
+        local arg = select(i, ...)
+        if arg == nil then
+          table.insert(parts, "nil")
+        else
+          table.insert(parts, vim.inspect(arg, {newline=''}))
+        end
+      end
+      logfile:write(table.concat(parts, '\t'), "\n")
+      logfile:flush()
+    end
+  end
+  -- Add some space to make it easier to distinguish different neovim runs.
+  logfile:write("\n")
+end
+
+-- This is put here on purpose after the loop above so that it doesn't
+-- interfere with iterating the levels
+vim.tbl_add_reverse_lookup(log.levels)
+
+function log.set_level(level)
+  if type(level) == 'string' then
+    current_log_level = assert(log.levels[level:upper()], string.format("Invalid log level: %q", level))
+  else
+    assert(type(level) == 'number', "level must be a number or string")
+    assert(log.levels[level], string.format("Invalid log level: %d", level))
+    current_log_level = level
+  end
+end
+
+-- Return whether the level is sufficient for logging.
+-- @param level number log level
+function log.should_log(level)
+  return level >= current_log_level
+end
+
+return log
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/protocol.lua b/runtime/lua/vim/lsp/protocol.lua
new file mode 100644
index 0000000000..1413a88ce2
--- /dev/null
+++ b/runtime/lua/vim/lsp/protocol.lua
@@ -0,0 +1,936 @@
+-- Protocol for the Microsoft Language Server Protocol (mslsp)
+
+local protocol = {}
+
+local function ifnil(a, b)
+  if a == nil then return b end
+  return a
+end
+
+
+--[=[
+-- Useful for interfacing with:
+-- https://github.com/microsoft/language-server-protocol/blob/gh-pages/_specifications/specification-3-14.md
+-- https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.md
+function transform_schema_comments()
+  nvim.command [[silent! '<,'>g/\/\*\*\|\*\/\|^$/d]]
+  nvim.command [[silent! '<,'>s/^\(\s*\) \* \=\(.*\)/\1--\2/]]
+end
+function transform_schema_to_table()
+  transform_schema_comments()
+  nvim.command [[silent! '<,'>s/: \S\+//]]
+  nvim.command [[silent! '<,'>s/export const //]]
+  nvim.command [[silent! '<,'>s/export namespace \(\S*\)\s*{/protocol.\1 = {/]]
+  nvim.command [[silent! '<,'>s/namespace \(\S*\)\s*{/protocol.\1 = {/]]
+end
+--]=]
+
+local constants = {
+  DiagnosticSeverity = {
+    -- Reports an error.
+    Error = 1;
+    -- Reports a warning.
+    Warning = 2;
+    -- Reports an information.
+    Information = 3;
+    -- Reports a hint.
+    Hint = 4;
+  };
+
+  MessageType = {
+    -- An error message.
+    Error = 1;
+    -- A warning message.
+    Warning = 2;
+    -- An information message.
+    Info = 3;
+    -- A log message.
+    Log = 4;
+  };
+
+  -- The file event type.
+  FileChangeType = {
+    -- The file got created.
+    Created = 1;
+    -- The file got changed.
+    Changed = 2;
+    -- The file got deleted.
+    Deleted = 3;
+  };
+
+  -- The kind of a completion entry.
+  CompletionItemKind = {
+    Text = 1;
+    Method = 2;
+    Function = 3;
+    Constructor = 4;
+    Field = 5;
+    Variable = 6;
+    Class = 7;
+    Interface = 8;
+    Module = 9;
+    Property = 10;
+    Unit = 11;
+    Value = 12;
+    Enum = 13;
+    Keyword = 14;
+    Snippet = 15;
+    Color = 16;
+    File = 17;
+    Reference = 18;
+    Folder = 19;
+    EnumMember = 20;
+    Constant = 21;
+    Struct = 22;
+    Event = 23;
+    Operator = 24;
+    TypeParameter = 25;
+  };
+
+  -- How a completion was triggered
+  CompletionTriggerKind = {
+    -- Completion was triggered by typing an identifier (24x7 code
+    -- complete), manual invocation (e.g Ctrl+Space) or via API.
+    Invoked = 1;
+    -- Completion was triggered by a trigger character specified by
+    -- the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+    TriggerCharacter = 2;
+    -- Completion was re-triggered as the current completion list is incomplete.
+    TriggerForIncompleteCompletions = 3;
+  };
+
+  -- A document highlight kind.
+  DocumentHighlightKind = {
+    -- A textual occurrence.
+    Text = 1;
+    -- Read-access of a symbol, like reading a variable.
+    Read = 2;
+    -- Write-access of a symbol, like writing to a variable.
+    Write = 3;
+  };
+
+  -- A symbol kind.
+  SymbolKind = {
+    File = 1;
+    Module = 2;
+    Namespace = 3;
+    Package = 4;
+    Class = 5;
+    Method = 6;
+    Property = 7;
+    Field = 8;
+    Constructor = 9;
+    Enum = 10;
+    Interface = 11;
+    Function = 12;
+    Variable = 13;
+    Constant = 14;
+    String = 15;
+    Number = 16;
+    Boolean = 17;
+    Array = 18;
+    Object = 19;
+    Key = 20;
+    Null = 21;
+    EnumMember = 22;
+    Struct = 23;
+    Event = 24;
+    Operator = 25;
+    TypeParameter = 26;
+  };
+
+  -- Represents reasons why a text document is saved.
+  TextDocumentSaveReason = {
+    -- Manually triggered, e.g. by the user pressing save, by starting debugging,
+    -- or by an API call.
+    Manual = 1;
+    -- Automatic after a delay.
+    AfterDelay = 2;
+    -- When the editor lost focus.
+    FocusOut = 3;
+  };
+
+  ErrorCodes = {
+    -- Defined by JSON RPC
+    ParseError           = -32700;
+    InvalidRequest       = -32600;
+    MethodNotFound       = -32601;
+    InvalidParams        = -32602;
+    InternalError        = -32603;
+    serverErrorStart     = -32099;
+    serverErrorEnd       = -32000;
+    ServerNotInitialized = -32002;
+    UnknownErrorCode     = -32001;
+    -- Defined by the protocol.
+    RequestCancelled     = -32800;
+    ContentModified      = -32801;
+  };
+
+  -- Describes the content type that a client supports in various
+  -- result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
+  --
+  -- Please note that `MarkupKinds` must not start with a `$`. This kinds
+  -- are reserved for internal usage.
+  MarkupKind = {
+    -- Plain text is supported as a content format
+    PlainText = 'plaintext';
+    -- Markdown is supported as a content format
+    Markdown = 'markdown';
+  };
+
+  ResourceOperationKind = {
+    -- Supports creating new files and folders.
+    Create = 'create';
+    -- Supports renaming existing files and folders.
+    Rename = 'rename';
+    -- Supports deleting existing files and folders.
+    Delete = 'delete';
+  };
+
+  FailureHandlingKind = {
+    -- Applying the workspace change is simply aborted if one of the changes provided
+    -- fails. All operations executed before the failing operation stay executed.
+    Abort = 'abort';
+    -- All operations are executed transactionally. That means they either all
+    -- succeed or no changes at all are applied to the workspace.
+    Transactional = 'transactional';
+    -- If the workspace edit contains only textual file changes they are executed transactionally.
+    -- If resource changes (create, rename or delete file) are part of the change the failure
+    -- handling strategy is abort.
+    TextOnlyTransactional = 'textOnlyTransactional';
+    -- The client tries to undo the operations already executed. But there is no
+    -- guarantee that this succeeds.
+    Undo = 'undo';
+  };
+
+  -- Known error codes for an `InitializeError`;
+  InitializeError = {
+    -- If the protocol version provided by the client can't be handled by the server.
+    -- @deprecated This initialize error got replaced by client capabilities. There is
+    -- no version handshake in version 3.0x
+    unknownProtocolVersion = 1;
+  };
+
+  -- Defines how the host (editor) should sync document changes to the language server.
+  TextDocumentSyncKind = {
+    -- Documents should not be synced at all.
+    None = 0;
+    -- Documents are synced by always sending the full content
+    -- of the document.
+    Full = 1;
+    -- Documents are synced by sending the full content on open.
+    -- After that only incremental updates to the document are
+    -- send.
+    Incremental = 2;
+  };
+
+  WatchKind = {
+    -- Interested in create events.
+    Create = 1;
+    -- Interested in change events
+    Change = 2;
+    -- Interested in delete events
+    Delete = 4;
+  };
+
+  -- Defines whether the insert text in a completion item should be interpreted as
+  -- plain text or a snippet.
+  InsertTextFormat = {
+    -- The primary text to be inserted is treated as a plain string.
+    PlainText = 1;
+    -- The primary text to be inserted is treated as a snippet.
+    --
+    -- A snippet can define tab stops and placeholders with `$1`, `$2`
+    -- and `${3:foo};`. `$0` defines the final tab stop, it defaults to
+    -- the end of the snippet. Placeholders with equal identifiers are linked,
+    -- that is typing in one will update others too.
+    Snippet = 2;
+  };
+
+  -- A set of predefined code action kinds
+  CodeActionKind = {
+    -- Empty kind.
+    Empty = '';
+    -- Base kind for quickfix actions
+    QuickFix = 'quickfix';
+    -- Base kind for refactoring actions
+    Refactor = 'refactor';
+    -- Base kind for refactoring extraction actions
+    --
+    -- Example extract actions:
+    --
+    -- - Extract method
+    -- - Extract function
+    -- - Extract variable
+    -- - Extract interface from class
+    -- - ...
+    RefactorExtract = 'refactor.extract';
+    -- Base kind for refactoring inline actions
+    --
+    -- Example inline actions:
+    --
+    -- - Inline function
+    -- - Inline variable
+    -- - Inline constant
+    -- - ...
+    RefactorInline = 'refactor.inline';
+    -- Base kind for refactoring rewrite actions
+    --
+    -- Example rewrite actions:
+    --
+    -- - Convert JavaScript function to class
+    -- - Add or remove parameter
+    -- - Encapsulate field
+    -- - Make method static
+    -- - Move method to base class
+    -- - ...
+    RefactorRewrite = 'refactor.rewrite';
+    -- Base kind for source actions
+    --
+    -- Source code actions apply to the entire file.
+    Source = 'source';
+    -- Base kind for an organize imports source action
+    SourceOrganizeImports = 'source.organizeImports';
+  };
+}
+
+for k, v in pairs(constants) do
+  vim.tbl_add_reverse_lookup(v)
+  protocol[k] = v
+end
+
+--[=[
+--Text document specific client capabilities.
+export interface TextDocumentClientCapabilities {
+  synchronization?: {
+    --Whether text document synchronization supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports sending will save notifications.
+    willSave?: boolean;
+    --The client supports sending a will save request and
+    --waits for a response providing text edits which will
+    --be applied to the document before it is saved.
+    willSaveWaitUntil?: boolean;
+    --The client supports did save notifications.
+    didSave?: boolean;
+  }
+  --Capabilities specific to the `textDocument/completion`
+  completion?: {
+    --Whether completion supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports the following `CompletionItem` specific
+    --capabilities.
+    completionItem?: {
+      --The client supports snippets as insert text.
+      --
+      --A snippet can define tab stops and placeholders with `$1`, `$2`
+      --and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+      --the end of the snippet. Placeholders with equal identifiers are linked,
+      --that is typing in one will update others too.
+      snippetSupport?: boolean;
+      --The client supports commit characters on a completion item.
+      commitCharactersSupport?: boolean
+      --The client supports the following content formats for the documentation
+      --property. The order describes the preferred format of the client.
+      documentationFormat?: MarkupKind[];
+      --The client supports the deprecated property on a completion item.
+      deprecatedSupport?: boolean;
+      --The client supports the preselect property on a completion item.
+      preselectSupport?: boolean;
+    }
+    completionItemKind?: {
+      --The completion item kind values the client supports. When this
+      --property exists the client also guarantees that it will
+      --handle values outside its set gracefully and falls back
+      --to a default value when unknown.
+      --
+      --If this property is not present the client only supports
+      --the completion items kinds from `Text` to `Reference` as defined in
+      --the initial version of the protocol.
+      valueSet?: CompletionItemKind[];
+    },
+    --The client supports to send additional context information for a
+    --`textDocument/completion` request.
+    contextSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/hover`
+  hover?: {
+    --Whether hover supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports the follow content formats for the content
+    --property. The order describes the preferred format of the client.
+    contentFormat?: MarkupKind[];
+  };
+  --Capabilities specific to the `textDocument/signatureHelp`
+  signatureHelp?: {
+    --Whether signature help supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports the following `SignatureInformation`
+    --specific properties.
+    signatureInformation?: {
+      --The client supports the follow content formats for the documentation
+      --property. The order describes the preferred format of the client.
+      documentationFormat?: MarkupKind[];
+      --Client capabilities specific to parameter information.
+      parameterInformation?: {
+        --The client supports processing label offsets instead of a
+        --simple label string.
+        --
+        --Since 3.14.0
+        labelOffsetSupport?: boolean;
+      }
+    };
+  };
+  --Capabilities specific to the `textDocument/references`
+  references?: {
+    --Whether references supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/documentHighlight`
+  documentHighlight?: {
+    --Whether document highlight supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/documentSymbol`
+  documentSymbol?: {
+    --Whether document symbol supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --Specific capabilities for the `SymbolKind`.
+    symbolKind?: {
+      --The symbol kind values the client supports. When this
+      --property exists the client also guarantees that it will
+      --handle values outside its set gracefully and falls back
+      --to a default value when unknown.
+      --
+      --If this property is not present the client only supports
+      --the symbol kinds from `File` to `Array` as defined in
+      --the initial version of the protocol.
+      valueSet?: SymbolKind[];
+    }
+    --The client supports hierarchical document symbols.
+    hierarchicalDocumentSymbolSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/formatting`
+  formatting?: {
+    --Whether formatting supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/rangeFormatting`
+  rangeFormatting?: {
+    --Whether range formatting supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/onTypeFormatting`
+  onTypeFormatting?: {
+    --Whether on type formatting supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/declaration`
+  declaration?: {
+    --Whether declaration supports dynamic registration. If this is set to `true`
+    --the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    --return value for the corresponding server capability as well.
+    dynamicRegistration?: boolean;
+    --The client supports additional metadata in the form of declaration links.
+    --
+    --Since 3.14.0
+    linkSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/definition`.
+  --
+  --Since 3.14.0
+  definition?: {
+    --Whether definition supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports additional metadata in the form of definition links.
+    linkSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/typeDefinition`
+  --
+  --Since 3.6.0
+  typeDefinition?: {
+    --Whether typeDefinition supports dynamic registration. If this is set to `true`
+    --the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    --return value for the corresponding server capability as well.
+    dynamicRegistration?: boolean;
+    --The client supports additional metadata in the form of definition links.
+    --
+    --Since 3.14.0
+    linkSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/implementation`.
+  --
+  --Since 3.6.0
+  implementation?: {
+    --Whether implementation supports dynamic registration. If this is set to `true`
+    --the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    --return value for the corresponding server capability as well.
+    dynamicRegistration?: boolean;
+    --The client supports additional metadata in the form of definition links.
+    --
+    --Since 3.14.0
+    linkSupport?: boolean;
+  };
+  --Capabilities specific to the `textDocument/codeAction`
+  codeAction?: {
+    --Whether code action supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client support code action literals as a valid
+    --response of the `textDocument/codeAction` request.
+    --
+    --Since 3.8.0
+    codeActionLiteralSupport?: {
+      --The code action kind is support with the following value
+      --set.
+      codeActionKind: {
+        --The code action kind values the client supports. When this
+        --property exists the client also guarantees that it will
+        --handle values outside its set gracefully and falls back
+        --to a default value when unknown.
+        valueSet: CodeActionKind[];
+      };
+    };
+  };
+  --Capabilities specific to the `textDocument/codeLens`
+  codeLens?: {
+    --Whether code lens supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/documentLink`
+  documentLink?: {
+    --Whether document link supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `textDocument/documentColor` and the
+  --`textDocument/colorPresentation` request.
+  --
+  --Since 3.6.0
+  colorProvider?: {
+    --Whether colorProvider supports dynamic registration. If this is set to `true`
+    --the client supports the new `(ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    --return value for the corresponding server capability as well.
+    dynamicRegistration?: boolean;
+  }
+  --Capabilities specific to the `textDocument/rename`
+  rename?: {
+    --Whether rename supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --The client supports testing for validity of rename operations
+    --before execution.
+    prepareSupport?: boolean;
+  };
+  --Capabilities specific to `textDocument/publishDiagnostics`.
+  publishDiagnostics?: {
+    --Whether the clients accepts diagnostics with related information.
+    relatedInformation?: boolean;
+  };
+  --Capabilities specific to `textDocument/foldingRange` requests.
+  --
+  --Since 3.10.0
+  foldingRange?: {
+    --Whether implementation supports dynamic registration for folding range providers. If this is set to `true`
+    --the client supports the new `(FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    --return value for the corresponding server capability as well.
+    dynamicRegistration?: boolean;
+    --The maximum number of folding ranges that the client prefers to receive per document. The value serves as a
+    --hint, servers are free to follow the limit.
+    rangeLimit?: number;
+    --If set, the client signals that it only supports folding complete lines. If set, client will
+    --ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange.
+    lineFoldingOnly?: boolean;
+  };
+}
+--]=]
+
+--[=[
+--Workspace specific client capabilities.
+export interface WorkspaceClientCapabilities {
+  --The client supports applying batch edits to the workspace by supporting
+  --the request 'workspace/applyEdit'
+  applyEdit?: boolean;
+  --Capabilities specific to `WorkspaceEdit`s
+  workspaceEdit?: {
+    --The client supports versioned document changes in `WorkspaceEdit`s
+    documentChanges?: boolean;
+    --The resource operations the client supports. Clients should at least
+    --support 'create', 'rename' and 'delete' files and folders.
+    resourceOperations?: ResourceOperationKind[];
+    --The failure handling strategy of a client if applying the workspace edit
+    --fails.
+    failureHandling?: FailureHandlingKind;
+  };
+  --Capabilities specific to the `workspace/didChangeConfiguration` notification.
+  didChangeConfiguration?: {
+    --Did change configuration notification supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+  didChangeWatchedFiles?: {
+    --Did change watched files notification supports dynamic registration. Please note
+    --that the current protocol doesn't support static configuration for file changes
+    --from the server side.
+    dynamicRegistration?: boolean;
+  };
+  --Capabilities specific to the `workspace/symbol` request.
+  symbol?: {
+    --Symbol request supports dynamic registration.
+    dynamicRegistration?: boolean;
+    --Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
+    symbolKind?: {
+      --The symbol kind values the client supports. When this
+      --property exists the client also guarantees that it will
+      --handle values outside its set gracefully and falls back
+      --to a default value when unknown.
+      --
+      --If this property is not present the client only supports
+      --the symbol kinds from `File` to `Array` as defined in
+      --the initial version of the protocol.
+      valueSet?: SymbolKind[];
+    }
+  };
+  --Capabilities specific to the `workspace/executeCommand` request.
+  executeCommand?: {
+    --Execute command supports dynamic registration.
+    dynamicRegistration?: boolean;
+  };
+  --The client has support for workspace folders.
+  --
+  --Since 3.6.0
+  workspaceFolders?: boolean;
+  --The client supports `workspace/configuration` requests.
+  --
+  --Since 3.6.0
+  configuration?: boolean;
+}
+--]=]
+
+function protocol.make_client_capabilities()
+  return {
+    textDocument = {
+      synchronization = {
+        dynamicRegistration = false;
+
+        -- TODO(ashkan) Send textDocument/willSave before saving (BufWritePre)
+        willSave = false;
+
+        -- TODO(ashkan) Implement textDocument/willSaveWaitUntil
+        willSaveWaitUntil = false;
+
+        -- Send textDocument/didSave after saving (BufWritePost)
+        didSave = true;
+      };
+      completion = {
+        dynamicRegistration = false;
+        completionItem = {
+
+          -- TODO(tjdevries): Is it possible to implement this in plain lua?
+          snippetSupport = false;
+          commitCharactersSupport = false;
+          preselectSupport = false;
+          deprecatedSupport = false;
+          documentationFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
+        };
+        completionItemKind = {
+          valueSet = (function()
+            local res = {}
+            for k in pairs(protocol.CompletionItemKind) do
+              if type(k) == 'number' then table.insert(res, k) end
+            end
+            return res
+          end)();
+        };
+
+        -- TODO(tjdevries): Implement this
+        contextSupport = false;
+      };
+      hover = {
+        dynamicRegistration = false;
+        contentFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
+      };
+      signatureHelp = {
+        dynamicRegistration = false;
+        signatureInformation = {
+          documentationFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
+          -- parameterInformation = {
+          --   labelOffsetSupport = false;
+          -- };
+        };
+      };
+      references = {
+        dynamicRegistration = false;
+      };
+      documentHighlight = {
+        dynamicRegistration = false
+      };
+      -- documentSymbol = {
+      --   dynamicRegistration = false;
+      --   symbolKind = {
+      --     valueSet = (function()
+      --       local res = {}
+      --       for k in pairs(protocol.SymbolKind) do
+      --         if type(k) == 'string' then table.insert(res, k) end
+      --       end
+      --       return res
+      --     end)();
+      --   };
+      --   hierarchicalDocumentSymbolSupport = false;
+      -- };
+    };
+    workspace = nil;
+    experimental = nil;
+  }
+end
+
+function protocol.make_text_document_position_params()
+  local position = vim.api.nvim_win_get_cursor(0)
+  return {
+    textDocument = {
+      uri = vim.uri_from_bufnr()
+    };
+    position = {
+      line = position[1] - 1;
+      character = position[2];
+    }
+  }
+end
+
+--[=[
+export interface DocumentFilter {
+  --A language id, like `typescript`.
+  language?: string;
+  --A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
+  scheme?: string;
+  --A glob pattern, like `*.{ts,js}`.
+  --
+  --Glob patterns can have the following syntax:
+  --- `*` to match one or more characters in a path segment
+  --- `?` to match on one character in a path segment
+  --- `**` to match any number of path segments, including none
+  --- `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+  --- `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+  --- `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+  pattern?: string;
+}
+--]=]
+
+--[[
+--Static registration options to be returned in the initialize request.
+interface StaticRegistrationOptions {
+  --The id used to register the request. The id can be used to deregister
+  --the request again. See also Registration#id.
+  id?: string;
+}
+
+export interface DocumentFilter {
+  --A language id, like `typescript`.
+  language?: string;
+  --A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
+  scheme?: string;
+  --A glob pattern, like `*.{ts,js}`.
+  --
+  --Glob patterns can have the following syntax:
+  --- `*` to match one or more characters in a path segment
+  --- `?` to match on one character in a path segment
+  --- `**` to match any number of path segments, including none
+  --- `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+  --- `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+  --- `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+  pattern?: string;
+}
+export type DocumentSelector = DocumentFilter[];
+export interface TextDocumentRegistrationOptions {
+  --A document selector to identify the scope of the registration. If set to null
+  --the document selector provided on the client side will be used.
+  documentSelector: DocumentSelector | null;
+}
+
+--Code Action options.
+export interface CodeActionOptions {
+  --CodeActionKinds that this server may return.
+  --
+  --The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+  --may list out every specific kind they provide.
+  codeActionKinds?: CodeActionKind[];
+}
+
+interface ServerCapabilities {
+  --Defines how text documents are synced. Is either a detailed structure defining each notification or
+  --for backwards compatibility the TextDocumentSyncKind number. If omitted it defaults to `TextDocumentSyncKind.None`.
+  textDocumentSync?: TextDocumentSyncOptions | number;
+  --The server provides hover support.
+  hoverProvider?: boolean;
+  --The server provides completion support.
+  completionProvider?: CompletionOptions;
+  --The server provides signature help support.
+  signatureHelpProvider?: SignatureHelpOptions;
+  --The server provides goto definition support.
+  definitionProvider?: boolean;
+  --The server provides Goto Type Definition support.
+  --
+  --Since 3.6.0
+  typeDefinitionProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
+  --The server provides Goto Implementation support.
+  --
+  --Since 3.6.0
+  implementationProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
+  --The server provides find references support.
+  referencesProvider?: boolean;
+  --The server provides document highlight support.
+  documentHighlightProvider?: boolean;
+  --The server provides document symbol support.
+  documentSymbolProvider?: boolean;
+  --The server provides workspace symbol support.
+  workspaceSymbolProvider?: boolean;
+  --The server provides code actions. The `CodeActionOptions` return type is only
+  --valid if the client signals code action literal support via the property
+  --`textDocument.codeAction.codeActionLiteralSupport`.
+  codeActionProvider?: boolean | CodeActionOptions;
+  --The server provides code lens.
+  codeLensProvider?: CodeLensOptions;
+  --The server provides document formatting.
+  documentFormattingProvider?: boolean;
+  --The server provides document range formatting.
+  documentRangeFormattingProvider?: boolean;
+  --The server provides document formatting on typing.
+  documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions;
+  --The server provides rename support. RenameOptions may only be
+  --specified if the client states that it supports
+  --`prepareSupport` in its initial `initialize` request.
+  renameProvider?: boolean | RenameOptions;
+  --The server provides document link support.
+  documentLinkProvider?: DocumentLinkOptions;
+  --The server provides color provider support.
+  --
+  --Since 3.6.0
+  colorProvider?: boolean | ColorProviderOptions | (ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+  --The server provides folding provider support.
+  --
+  --Since 3.10.0
+  foldingRangeProvider?: boolean | FoldingRangeProviderOptions | (FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+  --The server provides go to declaration support.
+  --
+  --Since 3.14.0
+  declarationProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
+  --The server provides execute command support.
+  executeCommandProvider?: ExecuteCommandOptions;
+  --Workspace specific server capabilities
+  workspace?: {
+    --The server supports workspace folder.
+    --
+    --Since 3.6.0
+    workspaceFolders?: {
+      * The server has support for workspace folders
+      supported?: boolean;
+      * Whether the server wants to receive workspace folder
+      * change notifications.
+      *
+      * If a strings is provided the string is treated as a ID
+      * under which the notification is registered on the client
+      * side. The ID can be used to unregister for these events
+      * using the `client/unregisterCapability` request.
+      changeNotifications?: string | boolean;
+    }
+  }
+  --Experimental server capabilities.
+  experimental?: any;
+}
+--]]
+function protocol.resolve_capabilities(server_capabilities)
+  local general_properties = {}
+  local text_document_sync_properties
+  do
+    local TextDocumentSyncKind = protocol.TextDocumentSyncKind
+    local textDocumentSync = server_capabilities.textDocumentSync
+    if textDocumentSync == nil then
+      -- Defaults if omitted.
+      text_document_sync_properties = {
+        text_document_open_close = false;
+        text_document_did_change = TextDocumentSyncKind.None;
+--        text_document_did_change = false;
+        text_document_will_save = false;
+        text_document_will_save_wait_until = false;
+        text_document_save = false;
+        text_document_save_include_text = false;
+      }
+    elseif type(textDocumentSync) == 'number' then
+      -- Backwards compatibility
+      if not TextDocumentSyncKind[textDocumentSync] then
+        return nil, "Invalid server TextDocumentSyncKind for textDocumentSync"
+      end
+      text_document_sync_properties = {
+        text_document_open_close = true;
+        text_document_did_change = textDocumentSync;
+        text_document_will_save = false;
+        text_document_will_save_wait_until = false;
+        text_document_save = false;
+        text_document_save_include_text = false;
+      }
+    elseif type(textDocumentSync) == 'table' then
+      text_document_sync_properties = {
+        text_document_open_close = ifnil(textDocumentSync.openClose, false);
+        text_document_did_change = ifnil(textDocumentSync.change, TextDocumentSyncKind.None);
+        text_document_will_save = ifnil(textDocumentSync.willSave, false);
+        text_document_will_save_wait_until = ifnil(textDocumentSync.willSaveWaitUntil, false);
+        text_document_save = ifnil(textDocumentSync.save, false);
+        text_document_save_include_text = ifnil(textDocumentSync.save and textDocumentSync.save.includeText, false);
+      }
+    else
+      return nil, string.format("Invalid type for textDocumentSync: %q", type(textDocumentSync))
+    end
+  end
+  general_properties.hover = server_capabilities.hoverProvider or false
+  general_properties.goto_definition = server_capabilities.definitionProvider or false
+  general_properties.find_references = server_capabilities.referencesProvider or false
+  general_properties.document_highlight = server_capabilities.documentHighlightProvider or false
+  general_properties.document_symbol = server_capabilities.documentSymbolProvider or false
+  general_properties.workspace_symbol = server_capabilities.workspaceSymbolProvider or false
+  general_properties.document_formatting = server_capabilities.documentFormattingProvider or false
+  general_properties.document_range_formatting = server_capabilities.documentRangeFormattingProvider or false
+
+  if server_capabilities.codeActionProvider == nil then
+    general_properties.code_action = false
+  elseif type(server_capabilities.codeActionProvider) == 'boolean' then
+    general_properties.code_action = server_capabilities.codeActionProvider
+  elseif type(server_capabilities.codeActionProvider) == 'table' then
+    -- TODO(ashkan) support CodeActionKind
+    general_properties.code_action = false
+  else
+    error("The server sent invalid codeActionProvider")
+  end
+
+  if server_capabilities.implementationProvider == nil then
+    general_properties.implementation = false
+  elseif type(server_capabilities.implementationProvider) == 'boolean' then
+    general_properties.implementation = server_capabilities.implementationProvider
+  elseif type(server_capabilities.implementationProvider) == 'table' then
+    -- TODO(ashkan) support more detailed implementation options.
+    general_properties.implementation = false
+  else
+    error("The server sent invalid implementationProvider")
+  end
+
+  local signature_help_properties
+  if server_capabilities.signatureHelpProvider == nil then
+    signature_help_properties = {
+      signature_help = false;
+      signature_help_trigger_characters = {};
+    }
+  elseif type(server_capabilities.signatureHelpProvider) == 'table' then
+    signature_help_properties = {
+      signature_help = true;
+      -- The characters that trigger signature help automatically.
+      signature_help_trigger_characters = server_capabilities.signatureHelpProvider.triggerCharacters or {};
+    }
+  else
+    error("The server sent invalid signatureHelpProvider")
+  end
+
+  return vim.tbl_extend("error"
+      , text_document_sync_properties
+      , signature_help_properties
+      , general_properties
+      )
+end
+
+return protocol
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/rpc.lua b/runtime/lua/vim/lsp/rpc.lua
new file mode 100644
index 0000000000..e0ec8863d6
--- /dev/null
+++ b/runtime/lua/vim/lsp/rpc.lua
@@ -0,0 +1,451 @@
+local uv = vim.loop
+local log = require('vim.lsp.log')
+local protocol = require('vim.lsp.protocol')
+local validate, schedule, schedule_wrap = vim.validate, vim.schedule, vim.schedule_wrap
+
+-- TODO replace with a better implementation.
+local function json_encode(data)
+  local status, result = pcall(vim.fn.json_encode, data)
+  if status then
+    return result
+  else
+    return nil, result
+  end
+end
+local function json_decode(data)
+  local status, result = pcall(vim.fn.json_decode, data)
+  if status then
+    return result
+  else
+    return nil, result
+  end
+end
+
+local function is_dir(filename)
+  local stat = vim.loop.fs_stat(filename)
+  return stat and stat.type == 'directory' or false
+end
+
+local NIL = vim.NIL
+local function convert_NIL(v)
+  if v == NIL then return nil end
+  return v
+end
+
+-- If a dictionary is passed in, turn it into a list of string of "k=v"
+-- Accepts a table which can be composed of k=v strings or map-like
+-- specification, such as:
+--
+-- ```
+-- {
+--   "PRODUCTION=false";
+--   "PATH=/usr/bin/";
+--   PORT = 123;
+--   HOST = "0.0.0.0";
+-- }
+-- ```
+--
+-- Non-string values will be cast with `tostring`
+local function force_env_list(final_env)
+  if final_env then
+    local env = final_env
+    final_env = {}
+    for k,v in pairs(env) do
+      -- If it's passed in as a dict, then convert to list of "k=v"
+      if type(k) == "string" then
+        table.insert(final_env, k..'='..tostring(v))
+      elseif type(v) == 'string' then
+        table.insert(final_env, v)
+      else
+        -- TODO is this right or should I exception here?
+        -- Try to coerce other values to string.
+        table.insert(final_env, tostring(v))
+      end
+    end
+    return final_env
+  end
+end
+
+local function format_message_with_content_length(encoded_message)
+  return table.concat {
+    'Content-Length: '; tostring(#encoded_message); '\r\n\r\n';
+    encoded_message;
+  }
+end
+
+--- Parse an LSP Message's header
+-- @param header: The header to parse.
+local function parse_headers(header)
+  if type(header) ~= 'string' then
+    return nil
+  end
+  local headers = {}
+  for line in vim.gsplit(header, '\r\n', true) do
+    if line == '' then
+      break
+    end
+    local key, value = line:match("^%s*(%S+)%s*:%s*(.+)%s*$")
+    if key then
+      key = key:lower():gsub('%-', '_')
+      headers[key] = value
+    else
+      local _ = log.error() and log.error("invalid header line %q", line)
+      error(string.format("invalid header line %q", line))
+    end
+  end
+  headers.content_length = tonumber(headers.content_length)
+      or error(string.format("Content-Length not found in headers. %q", header))
+  return headers
+end
+
+-- This is the start of any possible header patterns. The gsub converts it to a
+-- case insensitive pattern.
+local header_start_pattern = ("content"):gsub("%w", function(c) return "["..c..c:upper().."]" end)
+
+local function request_parser_loop()
+  local buffer = ''
+  while true do
+    -- A message can only be complete if it has a double CRLF and also the full
+    -- payload, so first let's check for the CRLFs
+    local start, finish = buffer:find('\r\n\r\n', 1, true)
+    -- Start parsing the headers
+    if start then
+      -- This is a workaround for servers sending initial garbage before
+      -- sending headers, such as if a bash script sends stdout. It assumes
+      -- that we know all of the headers ahead of time. At this moment, the
+      -- only valid headers start with "Content-*", so that's the thing we will
+      -- be searching for.
+      -- TODO(ashkan) I'd like to remove this, but it seems permanent :(
+      local buffer_start = buffer:find(header_start_pattern)
+      local headers = parse_headers(buffer:sub(buffer_start, start-1))
+      buffer = buffer:sub(finish+1)
+      local content_length = headers.content_length
+      -- Keep waiting for data until we have enough.
+      while #buffer < content_length do
+        buffer = buffer..(coroutine.yield()
+            or error("Expected more data for the body. The server may have died.")) -- TODO hmm.
+      end
+      local body = buffer:sub(1, content_length)
+      buffer = buffer:sub(content_length + 1)
+      -- Yield our data.
+      buffer = buffer..(coroutine.yield(headers, body)
+          or error("Expected more data for the body. The server may have died.")) -- TODO hmm.
+    else
+      -- Get more data since we don't have enough.
+      buffer = buffer..(coroutine.yield()
+          or error("Expected more data for the header. The server may have died.")) -- TODO hmm.
+    end
+  end
+end
+
+local client_errors = vim.tbl_add_reverse_lookup {
+  INVALID_SERVER_MESSAGE       = 1;
+  INVALID_SERVER_JSON          = 2;
+  NO_RESULT_CALLBACK_FOUND     = 3;
+  READ_ERROR                   = 4;
+  NOTIFICATION_HANDLER_ERROR   = 5;
+  SERVER_REQUEST_HANDLER_ERROR = 6;
+  SERVER_RESULT_CALLBACK_ERROR = 7;
+}
+
+local function format_rpc_error(err)
+  validate {
+    err = { err, 't' };
+  }
+  local code_name = assert(protocol.ErrorCodes[err.code], "err.code is invalid")
+  local message_parts = {"RPC", code_name}
+  if err.message then
+    table.insert(message_parts, "message = ")
+    table.insert(message_parts, string.format("%q", err.message))
+  end
+  if err.data then
+    table.insert(message_parts, "data = ")
+    table.insert(message_parts, vim.inspect(err.data))
+  end
+  return table.concat(message_parts, ' ')
+end
+
+local function rpc_response_error(code, message, data)
+  -- TODO should this error or just pick a sane error (like InternalError)?
+  local code_name = assert(protocol.ErrorCodes[code], 'Invalid rpc error code')
+  return setmetatable({
+    code = code;
+    message = message or code_name;
+    data = data;
+  }, {
+    __tostring = format_rpc_error;
+  })
+end
+
+local default_handlers = {}
+function default_handlers.notification(method, params)
+  local _ = log.debug() and log.debug('notification', method, params)
+end
+function default_handlers.server_request(method, params)
+  local _ = log.debug() and log.debug('server_request', method, params)
+  return nil, rpc_response_error(protocol.ErrorCodes.MethodNotFound)
+end
+function default_handlers.on_exit(code, signal)
+  local _ = log.info() and log.info("client exit", { code = code, signal = signal })
+end
+function default_handlers.on_error(code, err)
+  local _ = log.error() and log.error('client_error:', client_errors[code], err)
+end
+
+--- Create and start an RPC client.
+-- @param cmd [
+local function create_and_start_client(cmd, cmd_args, handlers, extra_spawn_params)
+  local _ = log.info() and log.info("Starting RPC client", {cmd = cmd, args = cmd_args, extra = extra_spawn_params})
+  validate {
+    cmd = { cmd, 's' };
+    cmd_args = { cmd_args, 't' };
+    handlers = { handlers, 't', true };
+  }
+
+  if not (vim.fn.executable(cmd) == 1) then
+    error(string.format("The given command %q is not executable.", cmd))
+  end
+  if handlers then
+    local user_handlers = handlers
+    handlers = {}
+    for handle_name, default_handler in pairs(default_handlers) do
+      local user_handler = user_handlers[handle_name]
+      if user_handler then
+        if type(user_handler) ~= 'function' then
+          error(string.format("handler.%s must be a function", handle_name))
+        end
+        -- server_request is wrapped elsewhere.
+        if not (handle_name == 'server_request'
+          or handle_name == 'on_exit') -- TODO this blocks the loop exiting for some reason.
+        then
+          user_handler = schedule_wrap(user_handler)
+        end
+        handlers[handle_name] = user_handler
+      else
+        handlers[handle_name] = default_handler
+      end
+    end
+  else
+    handlers = default_handlers
+  end
+
+  local stdin = uv.new_pipe(false)
+  local stdout = uv.new_pipe(false)
+  local stderr = uv.new_pipe(false)
+
+  local message_index = 0
+  local message_callbacks = {}
+
+  local handle, pid
+  do
+    local function onexit(code, signal)
+      stdin:close()
+      stdout:close()
+      stderr:close()
+      handle:close()
+      -- Make sure that message_callbacks can be gc'd.
+      message_callbacks = nil
+      handlers.on_exit(code, signal)
+    end
+    local spawn_params = {
+      args = cmd_args;
+      stdio = {stdin, stdout, stderr};
+    }
+    if extra_spawn_params then
+      spawn_params.cwd = extra_spawn_params.cwd
+      if spawn_params.cwd then
+        assert(is_dir(spawn_params.cwd), "cwd must be a directory")
+      end
+      spawn_params.env = force_env_list(extra_spawn_params.env)
+    end
+    handle, pid = uv.spawn(cmd, spawn_params, onexit)
+  end
+
+  local function encode_and_send(payload)
+    local _ = log.debug() and log.debug("rpc.send.payload", payload)
+    if handle:is_closing() then return false end
+    -- TODO(ashkan) remove this once we have a Lua json_encode
+    schedule(function()
+      local encoded = assert(json_encode(payload))
+      stdin:write(format_message_with_content_length(encoded))
+    end)
+    return true
+  end
+
+  local function send_notification(method, params)
+    local _ = log.debug() and log.debug("rpc.notify", method, params)
+    return encode_and_send {
+      jsonrpc = "2.0";
+      method = method;
+      params = params;
+    }
+  end
+
+  local function send_response(request_id, err, result)
+    return encode_and_send {
+      id = request_id;
+      jsonrpc = "2.0";
+      error = err;
+      result = result;
+    }
+  end
+
+  local function send_request(method, params, callback)
+    validate {
+      callback = { callback, 'f' };
+    }
+    message_index = message_index + 1
+    local message_id = message_index
+    local result = encode_and_send {
+      id = message_id;
+      jsonrpc = "2.0";
+      method = method;
+      params = params;
+    }
+    if result then
+      message_callbacks[message_id] = schedule_wrap(callback)
+      return result, message_id
+    else
+      return false
+    end
+  end
+
+  stderr:read_start(function(_err, chunk)
+    if chunk then
+      local _ = log.error() and log.error("rpc", cmd, "stderr", chunk)
+    end
+  end)
+
+  local function on_error(errkind, ...)
+    assert(client_errors[errkind])
+    -- TODO what to do if this fails?
+    pcall(handlers.on_error, errkind, ...)
+  end
+  local function pcall_handler(errkind, status, head, ...)
+    if not status then
+      on_error(errkind, head, ...)
+      return status, head
+    end
+    return status, head, ...
+  end
+  local function try_call(errkind, fn, ...)
+    return pcall_handler(errkind, pcall(fn, ...))
+  end
+
+  -- TODO periodically check message_callbacks for old requests past a certain
+  -- time and log them. This would require storing the timestamp. I could call
+  -- them with an error then, perhaps.
+
+  local function handle_body(body)
+    local decoded, err = json_decode(body)
+    if not decoded then
+      on_error(client_errors.INVALID_SERVER_JSON, err)
+    end
+    local _ = log.debug() and log.debug("decoded", decoded)
+
+    if type(decoded.method) == 'string' and decoded.id then
+      -- Server Request
+      decoded.params = convert_NIL(decoded.params)
+      -- Schedule here so that the users functions don't trigger an error and
+      -- we can still use the result.
+      schedule(function()
+        local status, result
+        status, result, err = try_call(client_errors.SERVER_REQUEST_HANDLER_ERROR,
+            handlers.server_request, decoded.method, decoded.params)
+        local _ = log.debug() and log.debug("server_request: callback result", { status = status, result = result, err = err })
+        if status then
+          if not (result or err) then
+            -- TODO this can be a problem if `null` is sent for result. needs vim.NIL
+            error(string.format("method %q: either a result or an error must be sent to the server in response", decoded.method))
+          end
+          if err then
+            assert(type(err) == 'table', "err must be a table. Use rpc_response_error to help format errors.")
+            local code_name = assert(protocol.ErrorCodes[err.code], "Errors must use protocol.ErrorCodes. Use rpc_response_error to help format errors.")
+            err.message = err.message or code_name
+          end
+        else
+          -- On an exception, result will contain the error message.
+          err = rpc_response_error(protocol.ErrorCodes.InternalError, result)
+          result = nil
+        end
+        send_response(decoded.id, err, result)
+      end)
+    -- This works because we are expecting vim.NIL here
+    elseif decoded.id and (decoded.result or decoded.error) then
+      -- Server Result
+      decoded.error = convert_NIL(decoded.error)
+      decoded.result = convert_NIL(decoded.result)
+
+      -- We sent a number, so we expect a number.
+      local result_id = tonumber(decoded.id)
+      local callback = message_callbacks[result_id]
+      if callback then
+        message_callbacks[result_id] = nil
+        validate {
+          callback = { callback, 'f' };
+        }
+        if decoded.error then
+          decoded.error = setmetatable(decoded.error, {
+            __tostring = format_rpc_error;
+          })
+        end
+        try_call(client_errors.SERVER_RESULT_CALLBACK_ERROR,
+            callback, decoded.error, decoded.result)
+      else
+        on_error(client_errors.NO_RESULT_CALLBACK_FOUND, decoded)
+        local _ = log.error() and log.error("No callback found for server response id "..result_id)
+      end
+    elseif type(decoded.method) == 'string' then
+      -- Notification
+      decoded.params = convert_NIL(decoded.params)
+      try_call(client_errors.NOTIFICATION_HANDLER_ERROR,
+          handlers.notification, decoded.method, decoded.params)
+    else
+      -- Invalid server message
+      on_error(client_errors.INVALID_SERVER_MESSAGE, decoded)
+    end
+  end
+  -- TODO(ashkan) remove this once we have a Lua json_decode
+  handle_body = schedule_wrap(handle_body)
+
+  local request_parser = coroutine.wrap(request_parser_loop)
+  request_parser()
+  stdout:read_start(function(err, chunk)
+    if err then
+      -- TODO better handling. Can these be intermittent errors?
+      on_error(client_errors.READ_ERROR, err)
+      return
+    end
+    -- This should signal that we are done reading from the client.
+    if not chunk then return end
+    -- Flush anything in the parser by looping until we don't get a result
+    -- anymore.
+    while true do
+      local headers, body = request_parser(chunk)
+      -- If we successfully parsed, then handle the response.
+      if headers then
+        handle_body(body)
+        -- Set chunk to empty so that we can call request_parser to get
+        -- anything existing in the parser to flush.
+        chunk = ''
+      else
+        break
+      end
+    end
+  end)
+
+  return {
+    pid = pid;
+    handle = handle;
+    request = send_request;
+    notify = send_notification;
+  }
+end
+
+return {
+  start = create_and_start_client;
+  rpc_response_error = rpc_response_error;
+  format_rpc_error = format_rpc_error;
+  client_errors = client_errors;
+}
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
new file mode 100644
index 0000000000..f96e0f01a8
--- /dev/null
+++ b/runtime/lua/vim/lsp/util.lua
@@ -0,0 +1,557 @@
+local protocol = require 'vim.lsp.protocol'
+local validate = vim.validate
+local api = vim.api
+
+local M = {}
+
+local split = vim.split
+local function split_lines(value)
+  return split(value, '\n', true)
+end
+
+local list_extend = vim.list_extend
+
+--- Find the longest shared prefix between prefix and word.
+-- e.g. remove_prefix("123tes", "testing") == "ting"
+local function remove_prefix(prefix, word)
+  local max_prefix_length = math.min(#prefix, #word)
+  local prefix_length = 0
+  for i = 1, max_prefix_length do
+    local current_line_suffix = prefix:sub(-i)
+    local word_prefix = word:sub(1, i)
+    if current_line_suffix == word_prefix then
+      prefix_length = i
+    end
+  end
+  return word:sub(prefix_length + 1)
+end
+
+local function resolve_bufnr(bufnr)
+  if bufnr == nil or bufnr == 0 then
+    return api.nvim_get_current_buf()
+  end
+  return bufnr
+end
+
+-- local valid_windows_path_characters = "[^<>:\"/\\|?*]"
+-- local valid_unix_path_characters = "[^/]"
+-- https://github.com/davidm/lua-glob-pattern
+-- https://stackoverflow.com/questions/1976007/what-characters-are-forbidden-in-windows-and-linux-directory-names
+-- function M.glob_to_regex(glob)
+-- end
+
+--- Apply the TextEdit response.
+-- @params TextEdit [table] see https://microsoft.github.io/language-server-protocol/specification
+function M.text_document_apply_text_edit(text_edit, bufnr)
+  bufnr = resolve_bufnr(bufnr)
+  local range = text_edit.range
+  local start = range.start
+  local finish = range['end']
+  local new_lines = split_lines(text_edit.newText)
+  if start.character == 0 and finish.character == 0 then
+    api.nvim_buf_set_lines(bufnr, start.line, finish.line, false, new_lines)
+    return
+  end
+  api.nvim_err_writeln('apply_text_edit currently only supports character ranges starting at 0')
+  error('apply_text_edit currently only supports character ranges starting at 0')
+  return
+  --  TODO test and finish this support for character ranges.
+--  local lines = api.nvim_buf_get_lines(0, start.line, finish.line + 1, false)
+--  local suffix = lines[#lines]:sub(finish.character+2)
+--  local prefix = lines[1]:sub(start.character+2)
+--  new_lines[#new_lines] = new_lines[#new_lines]..suffix
+--  new_lines[1] = prefix..new_lines[1]
+--  api.nvim_buf_set_lines(0, start.line, finish.line, false, new_lines)
+end
+
+-- textDocument/completion response returns one of CompletionItem[], CompletionList or null.
+-- https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
+function M.extract_completion_items(result)
+  if type(result) == 'table' and result.items then
+    return result.items
+  elseif result ~= nil then
+    return result
+  else
+    return {}
+  end
+end
+
+--- Apply the TextDocumentEdit response.
+-- @params TextDocumentEdit [table] see https://microsoft.github.io/language-server-protocol/specification
+function M.text_document_apply_text_document_edit(text_document_edit, bufnr)
+  -- local text_document = text_document_edit.textDocument
+  -- TODO use text_document_version?
+  -- local text_document_version = text_document.version
+
+  -- TODO technically, you could do this without doing multiple buf_get/set
+  -- by getting the full region (smallest line and largest line) and doing
+  -- the edits on the buffer, and then applying the buffer at the end.
+  -- I'm not sure if that's better.
+  for _, text_edit in ipairs(text_document_edit.edits) do
+    M.text_document_apply_text_edit(text_edit, bufnr)
+  end
+end
+
+function M.get_current_line_to_cursor()
+  local pos = api.nvim_win_get_cursor(0)
+  local line = assert(api.nvim_buf_get_lines(0, pos[1]-1, pos[1], false)[1])
+  return line:sub(pos[2]+1)
+end
+
+--- Getting vim complete-items with incomplete flag.
+-- @params CompletionItem[], CompletionList or nil (https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
+-- @return { matches = complete-items table, incomplete = boolean  }
+function M.text_document_completion_list_to_complete_items(result, line_prefix)
+  local items = M.extract_completion_items(result)
+  if vim.tbl_isempty(items) then
+    return {}
+  end
+  -- Only initialize if we have some items.
+  if not line_prefix then
+    line_prefix = M.get_current_line_to_cursor()
+  end
+
+  local matches = {}
+
+  for _, completion_item in ipairs(items) do
+    local info = ' '
+    local documentation = completion_item.documentation
+    if documentation then
+      if type(documentation) == 'string' and documentation ~= '' then
+        info = documentation
+      elseif type(documentation) == 'table' and type(documentation.value) == 'string' then
+        info = documentation.value
+      -- else
+        -- TODO(ashkan) Validation handling here?
+      end
+    end
+
+    local word = completion_item.insertText or completion_item.label
+
+    -- Ref: `:h complete-items`
+    table.insert(matches, {
+      word = remove_prefix(line_prefix, word),
+      abbr = completion_item.label,
+      kind = protocol.CompletionItemKind[completion_item.kind] or '',
+      menu = completion_item.detail or '',
+      info = info,
+      icase = 1,
+      dup = 0,
+      empty = 1,
+    })
+  end
+
+  return matches
+end
+
+-- @params WorkspaceEdit [table] see https://microsoft.github.io/language-server-protocol/specification
+function M.workspace_apply_workspace_edit(workspace_edit)
+  if workspace_edit.documentChanges then
+    for _, change in ipairs(workspace_edit.documentChanges) do
+      if change.kind then
+        -- TODO(ashkan) handle CreateFile/RenameFile/DeleteFile
+        error(string.format("Unsupported change: %q", vim.inspect(change)))
+      else
+        M.text_document_apply_text_document_edit(change)
+      end
+    end
+    return
+  end
+
+  if workspace_edit.changes == nil or #workspace_edit.changes == 0 then
+    return
+  end
+
+  for uri, changes in pairs(workspace_edit.changes) do
+    local fname = vim.uri_to_fname(uri)
+    -- TODO improve this approach. Try to edit open buffers without switching.
+    -- Not sure how to handle files which aren't open. This is deprecated
+    -- anyway, so I guess it could be left as is.
+    api.nvim_command('edit '..fname)
+    for _, change in ipairs(changes) do
+      M.text_document_apply_text_edit(change)
+    end
+  end
+end
+
+--- Convert any of MarkedString | MarkedString[] | MarkupContent into markdown text lines
+-- see https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_hover
+-- Useful for textDocument/hover, textDocument/signatureHelp, and potentially others.
+function M.convert_input_to_markdown_lines(input, contents)
+  contents = contents or {}
+  -- MarkedString variation 1
+  if type(input) == 'string' then
+    list_extend(contents, split_lines(input))
+  else
+    assert(type(input) == 'table', "Expected a table for Hover.contents")
+    -- MarkupContent
+    if input.kind then
+      -- The kind can be either plaintext or markdown. However, either way we
+      -- will just be rendering markdown, so we handle them both the same way.
+      -- TODO these can have escaped/sanitized html codes in markdown. We
+      -- should make sure we handle this correctly.
+
+      -- Some servers send input.value as empty, so let's ignore this :(
+      -- assert(type(input.value) == 'string')
+      list_extend(contents, split_lines(input.value or ''))
+    -- MarkupString variation 2
+    elseif input.language then
+      -- Some servers send input.value as empty, so let's ignore this :(
+      -- assert(type(input.value) == 'string')
+      table.insert(contents, "```"..input.language)
+      list_extend(contents, split_lines(input.value or ''))
+      table.insert(contents, "```")
+    -- By deduction, this must be MarkedString[]
+    else
+      -- Use our existing logic to handle MarkedString
+      for _, marked_string in ipairs(input) do
+        M.convert_input_to_markdown_lines(marked_string, contents)
+      end
+    end
+  end
+  if contents[1] == '' or contents[1] == nil then
+    return {}
+  end
+  return contents
+end
+
+function M.make_floating_popup_options(width, height, opts)
+  validate {
+    opts = { opts, 't', true };
+  }
+  opts = opts or {}
+  validate {
+    ["opts.offset_x"] = { opts.offset_x, 'n', true };
+    ["opts.offset_y"] = { opts.offset_y, 'n', true };
+  }
+
+  local anchor = ''
+  local row, col
+
+  if vim.fn.winline() <= height then
+    anchor = anchor..'N'
+    row = 1
+  else
+    anchor = anchor..'S'
+    row = 0
+  end
+
+  if vim.fn.wincol() + width <= api.nvim_get_option('columns') then
+    anchor = anchor..'W'
+    col = 0
+  else
+    anchor = anchor..'E'
+    col = 1
+  end
+
+  return {
+    anchor = anchor,
+    col = col + (opts.offset_x or 0),
+    height = height,
+    relative = 'cursor',
+    row = row + (opts.offset_y or 0),
+    style = 'minimal',
+    width = width,
+  }
+end
+
+function M.open_floating_preview(contents, filetype, opts)
+  validate {
+    contents = { contents, 't' };
+    filetype = { filetype, 's', true };
+    opts = { opts, 't', true };
+  }
+
+  -- Trim empty lines from the end.
+  for i = #contents, 1, -1 do
+    if #contents[i] == 0 then
+      table.remove(contents)
+    else
+      break
+    end
+  end
+
+  local width = 0
+  local height = #contents
+  for i, line in ipairs(contents) do
+    -- Clean up the input and add left pad.
+    line = " "..line:gsub("\r", "")
+    -- TODO(ashkan) use nvim_strdisplaywidth if/when that is introduced.
+    local line_width = vim.fn.strdisplaywidth(line)
+    width = math.max(line_width, width)
+    contents[i] = line
+  end
+  -- Add right padding of 1 each.
+  width = width + 1
+
+  local floating_bufnr = api.nvim_create_buf(false, true)
+  if filetype then
+    api.nvim_buf_set_option(floating_bufnr, 'filetype', filetype)
+  end
+  local float_option = M.make_floating_popup_options(width, height, opts)
+  local floating_winnr = api.nvim_open_win(floating_bufnr, false, float_option)
+  if filetype == 'markdown' then
+    api.nvim_win_set_option(floating_winnr, 'conceallevel', 2)
+  end
+  api.nvim_buf_set_lines(floating_bufnr, 0, -1, true, contents)
+  api.nvim_buf_set_option(floating_bufnr, 'modifiable', false)
+  api.nvim_command("autocmd CursorMoved <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
+  return floating_bufnr, floating_winnr
+end
+
+local function validate_lsp_position(pos)
+  validate { pos = {pos, 't'} }
+  validate {
+    line = {pos.line, 'n'};
+    character = {pos.character, 'n'};
+  }
+  return true
+end
+
+function M.open_floating_peek_preview(bufnr, start, finish, opts)
+  validate {
+    bufnr = {bufnr, 'n'};
+    start = {start, validate_lsp_position, 'valid start Position'};
+    finish = {finish, validate_lsp_position, 'valid finish Position'};
+    opts = { opts, 't', true };
+  }
+  local width = math.max(finish.character - start.character + 1, 1)
+  local height = math.max(finish.line - start.line + 1, 1)
+  local floating_winnr = api.nvim_open_win(bufnr, false, M.make_floating_popup_options(width, height, opts))
+  api.nvim_win_set_cursor(floating_winnr, {start.line+1, start.character})
+  api.nvim_command("autocmd CursorMoved * ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
+  return floating_winnr
+end
+
+
+local function highlight_range(bufnr, ns, hiname, start, finish)
+  if start[1] == finish[1] then
+    -- TODO care about encoding here since this is in byte index?
+    api.nvim_buf_add_highlight(bufnr, ns, hiname, start[1], start[2], finish[2])
+  else
+    api.nvim_buf_add_highlight(bufnr, ns, hiname, start[1], start[2], -1)
+    for line = start[1] + 1, finish[1] - 1 do
+      api.nvim_buf_add_highlight(bufnr, ns, hiname, line, 0, -1)
+    end
+    api.nvim_buf_add_highlight(bufnr, ns, hiname, finish[1], 0, finish[2])
+  end
+end
+
+do
+  local all_buffer_diagnostics = {}
+
+  local diagnostic_ns = api.nvim_create_namespace("vim_lsp_diagnostics")
+
+  local default_severity_highlight = {
+    [protocol.DiagnosticSeverity.Error] = { guifg = "Red" };
+    [protocol.DiagnosticSeverity.Warning] = { guifg = "Orange" };
+    [protocol.DiagnosticSeverity.Information] = { guifg = "LightBlue" };
+    [protocol.DiagnosticSeverity.Hint] = { guifg = "LightGrey" };
+  }
+
+  local underline_highlight_name = "LspDiagnosticsUnderline"
+  api.nvim_command(string.format("highlight %s gui=underline cterm=underline", underline_highlight_name))
+
+  local function find_color_rgb(color)
+    local rgb_hex = api.nvim_get_color_by_name(color)
+    validate { color = {color, function() return rgb_hex ~= -1 end, "valid color name"} }
+    return rgb_hex
+  end
+
+  --- Determine whether to use black or white text
+  -- Ref: https://stackoverflow.com/a/1855903/837964
+  -- https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
+  local function color_is_bright(r, g, b)
+    -- Counting the perceptive luminance - human eye favors green color
+    local luminance = (0.299*r + 0.587*g + 0.114*b)/255
+    if luminance > 0.5 then
+      return true -- Bright colors, black font
+    else
+      return false -- Dark colors, white font
+    end
+  end
+
+  local severity_highlights = {}
+
+  function M.set_severity_highlights(highlights)
+    validate {highlights = {highlights, 't'}}
+    for severity, default_color in pairs(default_severity_highlight) do
+      local severity_name = protocol.DiagnosticSeverity[severity]
+      local highlight_name = "LspDiagnostics"..severity_name
+      local hi_info = highlights[severity] or default_color
+      -- Try to fill in the foreground color with a sane default.
+      if not hi_info.guifg and hi_info.guibg then
+        -- TODO(ashkan) move this out when bitop is guaranteed to be included.
+        local bit = require 'bit'
+        local band, rshift = bit.band, bit.rshift
+        local rgb = find_color_rgb(hi_info.guibg)
+        local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
+        hi_info.guifg = is_bright and "Black" or "White"
+      end
+      if not hi_info.ctermfg and hi_info.ctermbg then
+        -- TODO(ashkan) move this out when bitop is guaranteed to be included.
+        local bit = require 'bit'
+        local band, rshift = bit.band, bit.rshift
+        local rgb = find_color_rgb(hi_info.ctermbg)
+        local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
+        hi_info.ctermfg = is_bright and "Black" or "White"
+      end
+      local cmd_parts = {"highlight", highlight_name}
+      for k, v in pairs(hi_info) do
+        table.insert(cmd_parts, k.."="..v)
+      end
+      api.nvim_command(table.concat(cmd_parts, ' '))
+      severity_highlights[severity] = highlight_name
+    end
+  end
+
+  function M.buf_clear_diagnostics(bufnr)
+    validate { bufnr = {bufnr, 'n', true} }
+    bufnr = bufnr == 0 and api.nvim_get_current_buf() or bufnr
+    api.nvim_buf_clear_namespace(bufnr, diagnostic_ns, 0, -1)
+  end
+
+  -- Initialize with the defaults.
+  M.set_severity_highlights(default_severity_highlight)
+
+  function M.get_severity_highlight_name(severity)
+    return severity_highlights[severity]
+  end
+
+  function M.show_line_diagnostics()
+    local bufnr = api.nvim_get_current_buf()
+    local line = api.nvim_win_get_cursor(0)[1] - 1
+    -- local marks = api.nvim_buf_get_extmarks(bufnr, diagnostic_ns, {line, 0}, {line, -1}, {})
+    -- if #marks == 0 then
+    --   return
+    -- end
+    -- local buffer_diagnostics = all_buffer_diagnostics[bufnr]
+    local lines = {"Diagnostics:"}
+    local highlights = {{0, "Bold"}}
+
+    local buffer_diagnostics = all_buffer_diagnostics[bufnr]
+    if not buffer_diagnostics then return end
+    local line_diagnostics = buffer_diagnostics[line]
+    if not line_diagnostics then return end
+
+    for i, diagnostic in ipairs(line_diagnostics) do
+    -- for i, mark in ipairs(marks) do
+    --   local mark_id = mark[1]
+    --   local diagnostic = buffer_diagnostics[mark_id]
+
+      -- TODO(ashkan) make format configurable?
+      local prefix = string.format("%d. ", i)
+      local hiname = severity_highlights[diagnostic.severity]
+      local message_lines = split_lines(diagnostic.message)
+      table.insert(lines, prefix..message_lines[1])
+      table.insert(highlights, {#prefix + 1, hiname})
+      for j = 2, #message_lines do
+        table.insert(lines, message_lines[j])
+        table.insert(highlights, {0, hiname})
+      end
+    end
+    local popup_bufnr, winnr = M.open_floating_preview(lines, 'plaintext')
+    for i, hi in ipairs(highlights) do
+      local prefixlen, hiname = unpack(hi)
+      -- Start highlight after the prefix
+      api.nvim_buf_add_highlight(popup_bufnr, -1, hiname, i-1, prefixlen, -1)
+    end
+    return popup_bufnr, winnr
+  end
+
+  function M.buf_diagnostics_save_positions(bufnr, diagnostics)
+    validate {
+      bufnr = {bufnr, 'n', true};
+      diagnostics = {diagnostics, 't', true};
+    }
+    if not diagnostics then return end
+    bufnr = bufnr == 0 and api.nvim_get_current_buf() or bufnr
+
+    if not all_buffer_diagnostics[bufnr] then
+      -- Clean up our data when the buffer unloads.
+      api.nvim_buf_attach(bufnr, false, {
+        on_detach = function(b)
+          all_buffer_diagnostics[b] = nil
+        end
+      })
+    end
+    all_buffer_diagnostics[bufnr] = {}
+    local buffer_diagnostics = all_buffer_diagnostics[bufnr]
+
+    for _, diagnostic in ipairs(diagnostics) do
+      local start = diagnostic.range.start
+      -- local mark_id = api.nvim_buf_set_extmark(bufnr, diagnostic_ns, 0, start.line, 0, {})
+      -- buffer_diagnostics[mark_id] = diagnostic
+      local line_diagnostics = buffer_diagnostics[start.line]
+      if not line_diagnostics then
+        line_diagnostics = {}
+        buffer_diagnostics[start.line] = line_diagnostics
+      end
+      table.insert(line_diagnostics, diagnostic)
+    end
+  end
+
+
+  function M.buf_diagnostics_underline(bufnr, diagnostics)
+    for _, diagnostic in ipairs(diagnostics) do
+      local start = diagnostic.range.start
+      local finish = diagnostic.range["end"]
+
+      -- TODO care about encoding here since this is in byte index?
+      highlight_range(bufnr, diagnostic_ns, underline_highlight_name,
+          {start.line, start.character},
+          {finish.line, finish.character}
+      )
+    end
+  end
+
+  function M.buf_diagnostics_virtual_text(bufnr, diagnostics)
+    local buffer_line_diagnostics = all_buffer_diagnostics[bufnr]
+    if not buffer_line_diagnostics then
+      M.buf_diagnostics_save_positions(bufnr, diagnostics)
+    end
+    buffer_line_diagnostics = all_buffer_diagnostics[bufnr]
+    if not buffer_line_diagnostics then
+      return
+    end
+    for line, line_diags in pairs(buffer_line_diagnostics) do
+      local virt_texts = {}
+      for i = 1, #line_diags - 1 do
+        table.insert(virt_texts, {"■", severity_highlights[line_diags[i].severity]})
+      end
+      local last = line_diags[#line_diags]
+      -- TODO(ashkan) use first line instead of subbing 2 spaces?
+      table.insert(virt_texts, {"■ "..last.message:gsub("\r", ""):gsub("\n", "  "), severity_highlights[last.severity]})
+      api.nvim_buf_set_virtual_text(bufnr, diagnostic_ns, line, virt_texts, {})
+    end
+  end
+end
+
+function M.buf_loclist(bufnr, locations)
+  local targetwin
+  for _, winnr in ipairs(api.nvim_list_wins()) do
+    local winbuf = api.nvim_win_get_buf(winnr)
+    if winbuf == bufnr then
+      targetwin = winnr
+      break
+    end
+  end
+  if not targetwin then return end
+
+  local items = {}
+  local path = api.nvim_buf_get_name(bufnr)
+  for _, d in ipairs(locations) do
+    -- TODO: URL parsing here?
+    local start = d.range.start
+    table.insert(items, {
+        filename = path,
+        lnum = start.line + 1,
+        col = start.character + 1,
+        text = d.message,
+    })
+  end
+  vim.fn.setloclist(targetwin, items, ' ', 'Language Server')
+end
+
+return M
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index e987e07a2a..ff89acc524 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -98,6 +98,38 @@ function vim.split(s,sep,plain)
   return t
 end
 
+--- Return a list of all keys used in a table.
+--- However, the order of the return table of keys is not guaranteed.
+---
+--@see From https://github.com/premake/premake-core/blob/master/src/base/table.lua
+---
+--@param t Table
+--@returns list of keys
+function vim.tbl_keys(t)
+  assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
+
+  local keys = {}
+  for k, _ in pairs(t) do
+    table.insert(keys, k)
+  end
+  return keys
+end
+
+--- Return a list of all values used in a table.
+--- However, the order of the return table of values is not guaranteed.
+---
+--@param t Table
+--@returns list of values
+function vim.tbl_values(t)
+  assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
+
+  local values = {}
+  for _, v in pairs(t) do
+    table.insert(values, v)
+  end
+  return values
+end
+
 --- Checks if a list-like (vector) table contains `value`.
 ---
 --@param t Table to check
@@ -114,6 +146,16 @@ function vim.tbl_contains(t, value)
   return false
 end
 
+-- Returns true if the table is empty, and contains no indexed or keyed values.
+--
+--@see From https://github.com/premake/premake-core/blob/master/src/base/table.lua
+--
+--@param t Table to check
+function vim.tbl_isempty(t)
+  assert(type(t) == 'table', string.format("Expected table, got %s", type(t)))
+  return next(t) == nil
+end
+
 --- Merges two or more map-like tables.
 ---
 --@see |extend()|
@@ -145,13 +187,69 @@ function vim.tbl_extend(behavior, ...)
   return ret
 end
 
+--- Deep compare values for equality
+function vim.deep_equal(a, b)
+  if a == b then return true end
+  if type(a) ~= type(b) then return false end
+  if type(a) == 'table' then
+    -- TODO improve this algorithm's performance.
+    for k, v in pairs(a) do
+      if not vim.deep_equal(v, b[k]) then
+        return false
+      end
+    end
+    for k, v in pairs(b) do
+      if not vim.deep_equal(v, a[k]) then
+        return false
+      end
+    end
+    return true
+  end
+  return false
+end
+
+--- Add the reverse lookup values to an existing table.
+--- For example:
+--- `tbl_add_reverse_lookup { A = 1 } == { [1] = 'A', A = 1 }`
+--
+--Do note that it *modifies* the input.
+--@param o table The table to add the reverse to.
+function vim.tbl_add_reverse_lookup(o)
+  local keys = vim.tbl_keys(o)
+  for _, k in ipairs(keys) do
+    local v = o[k]
+    if o[v] then
+      error(string.format("The reverse lookup found an existing value for %q while processing key %q", tostring(v), tostring(k)))
+    end
+    o[v] = k
+  end
+  return o
+end
+
+--- Extends a list-like table with the values of another list-like table.
+---
+--NOTE: This *mutates* dst!
+--@see |extend()|
+---
+--@param dst The list which will be modified and appended to.
+--@param src The list from which values will be inserted.
+function vim.list_extend(dst, src)
+  assert(type(dst) == 'table', "dst must be a table")
+  assert(type(src) == 'table', "src must be a table")
+  for _, v in ipairs(src) do
+    table.insert(dst, v)
+  end
+  return dst
+end
+
 --- Creates a copy of a list-like table such that any nested tables are
 --- "unrolled" and appended to the result.
 ---
+--@see From https://github.com/premake/premake-core/blob/master/src/base/table.lua
+---
 --@param t List-like table
 --@returns Flattened copy of the given list-like table.
 function vim.tbl_flatten(t)
-  -- From https://github.com/premake/premake-core/blob/master/src/base/table.lua
   local result = {}
   local function _tbl_flatten(_t)
     local n = #_t
@@ -168,6 +266,32 @@ function vim.tbl_flatten(t)
   return result
 end
 
+-- Determine whether a Lua table can be treated as an array.
+---
+--@params Table
+--@returns true: A non-empty array, false: A non-empty table, nil: An empty table
+function vim.tbl_islist(t)
+  if type(t) ~= 'table' then
+    return false
+  end
+
+  local count = 0
+
+  for k, _ in pairs(t) do
+    if type(k) == "number" then
+      count = count + 1
+    else
+      return false
+    end
+  end
+
+  if count > 0 then
+    return true
+  else
+    return nil
+  end
+end
+
 --- Trim whitespace (Lua pattern "%s") from both sides of a string.
 ---
 --@see https://www.lua.org/pil/20.2.html
@@ -279,3 +403,4 @@ function vim.is_callable(f)
 end
 
 return vim
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/uri.lua b/runtime/lua/vim/uri.lua
new file mode 100644
index 0000000000..0a6e0fcb97
--- /dev/null
+++ b/runtime/lua/vim/uri.lua
@@ -0,0 +1,89 @@
+--- TODO: This is implemented only for files now.
+-- https://tools.ietf.org/html/rfc3986
+-- https://tools.ietf.org/html/rfc2732
+-- https://tools.ietf.org/html/rfc2396
+
+
+local uri_decode
+do
+  local schar = string.char
+  local function hex_to_char(hex)
+    return schar(tonumber(hex, 16))
+  end
+  uri_decode = function(str)
+    return str:gsub("%%([a-fA-F0-9][a-fA-F0-9])", hex_to_char)
+  end
+end
+
+local uri_encode
+do
+  local PATTERNS = {
+    --- RFC 2396
+    -- https://tools.ietf.org/html/rfc2396#section-2.2
+    rfc2396 = "^A-Za-z0-9%-_.!~*'()";
+    --- RFC 2732
+    -- https://tools.ietf.org/html/rfc2732
+    rfc2732 = "^A-Za-z0-9%-_.!~*'()[]";
+    --- RFC 3986
+    -- https://tools.ietf.org/html/rfc3986#section-2.2
+    rfc3986 = "^A-Za-z0-9%-._~!$&'()*+,;=:@/";
+  }
+  local sbyte, tohex = string.byte
+  if jit then
+    tohex = require'bit'.tohex
+  else
+    tohex = function(b) return string.format("%02x", b) end
+  end
+  local function percent_encode_char(char)
+    return "%"..tohex(sbyte(char), 2)
+  end
+  uri_encode = function(text, rfc)
+    if not text then return end
+    local pattern = PATTERNS[rfc] or PATTERNS.rfc3986
+    return text:gsub("(["..pattern.."])", percent_encode_char)
+  end
+end
+
+
+local function is_windows_file_uri(uri)
+  return uri:match('^file:///[a-zA-Z]:') ~= nil
+end
+
+local function uri_from_fname(path)
+  local volume_path, fname = path:match("^([a-zA-Z]:)(.*)")
+  local is_windows = volume_path ~= nil
+  if is_windows then
+    path = volume_path..uri_encode(fname:gsub("\\", "/"))
+  else
+    path = uri_encode(path)
+  end
+  local uri_parts = {"file://"}
+  if is_windows then
+    table.insert(uri_parts, "/")
+  end
+  table.insert(uri_parts, path)
+  return table.concat(uri_parts)
+end
+
+local function uri_from_bufnr(bufnr)
+  return uri_from_fname(vim.api.nvim_buf_get_name(bufnr))
+end
+
+local function uri_to_fname(uri)
+  -- TODO improve this.
+  if is_windows_file_uri(uri) then
+    uri = uri:gsub('^file:///', '')
+    uri = uri:gsub('/', '\\')
+  else
+    uri = uri:gsub('^file://', '')
+  end
+
+  return uri_decode(uri)
+end
+
+return {
+  uri_from_fname = uri_from_fname,
+  uri_from_bufnr = uri_from_bufnr,
+  uri_to_fname = uri_to_fname,
+}
+-- vim:sw=2 ts=2 et
-- 
cgit 


From 69a0712a9c2bae0969f7a84e5ec321ce6120982b Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 11:23:50 -0800
Subject: Reduce code blocks in markdown previews.

If the preview is just a code block, then use the language as the
filetype instead of using markdown.
This reduces the size of the preview.
---
 runtime/lua/vim/lsp/builtin_callbacks.lua | 54 ++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/builtin_callbacks.lua b/runtime/lua/vim/lsp/builtin_callbacks.lua
index cc739ce3ad..717fda395e 100644
--- a/runtime/lua/vim/lsp/builtin_callbacks.lua
+++ b/runtime/lua/vim/lsp/builtin_callbacks.lua
@@ -81,6 +81,56 @@ builtin_callbacks['textDocument/publishDiagnostics'] = function(_, _, result)
   -- util.buf_loclist(bufnr, result.diagnostics)
 end
 
+local function focusable_popup()
+  local popup_win
+  return function(winnr)
+    if popup_win and nvim.win_is_valid(popup_win) then
+      if nvim.get_current_win() == popup_win then
+        nvim.ex.wincmd "p"
+      else
+        nvim.set_current_win(popup_win)
+      end
+      return
+    end
+    popup_win = winnr
+  end
+end
+
+local hover_popup = focusable_popup()
+
+local function trim_empty_lines(lines)
+  local result = {}
+  for _, line in ipairs(lines) do
+    if #line > 0 then
+      table.insert(result, line)
+    end
+  end
+  return result
+end
+
+-- Accepts markdown lines and tries to reduce it to a filetype if it is
+-- just a single code block.
+local function try_trim_code_blocks(lines)
+  local language_id = lines[1]:match("^```(.*)")
+  if language_id then
+    local has_inner_code_fence = false
+    for i = 2, (#lines - 1) do
+      local line = lines[i]
+      if line:sub(1,3) == '```' then
+        has_inner_code_fence = true
+        break
+      end
+    end
+    -- No inner code fences + starting with code fence = hooray.
+    if not has_inner_code_fence then
+      table.remove(lines, 1)
+      table.remove(lines)
+      return lines, language_id
+    end
+  end
+  return lines, 'markdown'
+end
+
 -- textDocument/hover
 -- https://microsoft.github.io/language-server-protocol/specification#textDocument_hover
 -- @params MarkedString | MarkedString[] | MarkupContent
@@ -91,10 +141,12 @@ builtin_callbacks['textDocument/hover'] = function(_, _, result)
 
   if result.contents ~= nil then
     local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+    markdown_lines = trim_empty_lines(markdown_lines)
     if vim.tbl_isempty(markdown_lines) then
       markdown_lines = { 'No information available' }
     end
-    util.open_floating_preview(markdown_lines, 'markdown')
+    local _, winnr = util.open_floating_preview(try_trim_code_blocks(markdown_lines))
+    hover_popup(winnr)
   end
 end
 
-- 
cgit 


From 3ae9b3781e0b66f5874971665b38314d61668627 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 11:34:10 -0800
Subject: Bugfix for floating_preview

Don't modify your inputs.
---
 runtime/lua/vim/lsp/util.lua | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index f96e0f01a8..707e2d0d3b 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -262,6 +262,9 @@ function M.open_floating_preview(contents, filetype, opts)
     opts = { opts, 't', true };
   }
 
+  -- Don't modify our inputs.
+  contents = vim.deepcopy(contents)
+
   -- Trim empty lines from the end.
   for i = #contents, 1, -1 do
     if #contents[i] == 0 then
-- 
cgit 


From 0904ffe387f825404d8467f9787678c2251728dd Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 11:36:50 -0800
Subject: Bugfixes.

- Return after an error in RPC.
- Use an empty vim table for serialization.
---
 runtime/lua/vim/lsp.lua     | 2 +-
 runtime/lua/vim/lsp/rpc.lua | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 9dbe03dace..4724ff0281 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -400,7 +400,7 @@ function lsp.start_client(config)
     rpc.request('initialize', initialize_params, function(init_err, result)
       assert(not init_err, tostring(init_err))
       assert(result, "server sent empty result")
-      rpc.notify('initialized', {})
+      rpc.notify('initialized', {[vim.type_idx]=vim.types.dictionary})
       client.initialized = true
       uninitialized_clients[client_id] = nil
       client.server_capabilities = assert(result.capabilities, "initialize result doesn't contain capabilities")
diff --git a/runtime/lua/vim/lsp/rpc.lua b/runtime/lua/vim/lsp/rpc.lua
index e0ec8863d6..a558f66a42 100644
--- a/runtime/lua/vim/lsp/rpc.lua
+++ b/runtime/lua/vim/lsp/rpc.lua
@@ -340,6 +340,7 @@ local function create_and_start_client(cmd, cmd_args, handlers, extra_spawn_para
     local decoded, err = json_decode(body)
     if not decoded then
       on_error(client_errors.INVALID_SERVER_JSON, err)
+      return
     end
     local _ = log.debug() and log.debug("decoded", decoded)
 
-- 
cgit 


From 568b4540884bb852b733dfcdd6a2da0d4fe2b42e Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 11:39:54 -0800
Subject: Add vim.uri_to_bufnr

---
 runtime/lua/vim/lsp/builtin_callbacks.lua | 8 ++------
 runtime/lua/vim/uri.lua                   | 7 ++++++-
 2 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/builtin_callbacks.lua b/runtime/lua/vim/lsp/builtin_callbacks.lua
index 717fda395e..a5e1162d02 100644
--- a/runtime/lua/vim/lsp/builtin_callbacks.lua
+++ b/runtime/lua/vim/lsp/builtin_callbacks.lua
@@ -62,14 +62,10 @@ builtin_callbacks['textDocument/rename'] = function(_, _, result)
   util.workspace_apply_workspace_edit(result)
 end
 
-local function uri_to_bufnr(uri)
-  return vim.fn.bufadd((vim.uri_to_fname(uri)))
-end
-
 builtin_callbacks['textDocument/publishDiagnostics'] = function(_, _, result)
   if not result then return end
   local uri = result.uri
-  local bufnr = uri_to_bufnr(uri)
+  local bufnr = vim.uri_to_bufnr(uri)
   if not bufnr then
     api.nvim_err_writeln(string.format("LSP.publishDiagnostics: Couldn't find buffer for %s", uri))
     return
@@ -154,7 +150,7 @@ builtin_callbacks['textDocument/peekDefinition'] = function(_, _, result)
   if result == nil or vim.tbl_isempty(result) then return end
   -- TODO(ashkan) what to do with multiple locations?
   result = result[1]
-  local bufnr = uri_to_bufnr(result.uri)
+  local bufnr = vim.uri_to_bufnr(result.uri)
   assert(bufnr)
   local start = result.range.start
   local finish = result.range["end"]
diff --git a/runtime/lua/vim/uri.lua b/runtime/lua/vim/uri.lua
index 0a6e0fcb97..1065f84f4c 100644
--- a/runtime/lua/vim/uri.lua
+++ b/runtime/lua/vim/uri.lua
@@ -77,13 +77,18 @@ local function uri_to_fname(uri)
   else
     uri = uri:gsub('^file://', '')
   end
-
   return uri_decode(uri)
 end
 
+-- Return or create a buffer for a uri.
+local function uri_to_bufnr(uri)
+  return vim.fn.bufadd((uri_to_fname(uri)))
+end
+
 return {
   uri_from_fname = uri_from_fname,
   uri_from_bufnr = uri_from_bufnr,
   uri_to_fname = uri_to_fname,
+  uri_to_bufnr = uri_to_bufnr,
 }
 -- vim:sw=2 ts=2 et
-- 
cgit 


From ff65cc990afba288df6d39d6f95901cf0786c668 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 11:41:45 -0800
Subject: Bugfix. Don't use nvim.lua that doesn't exist :)

---
 runtime/lua/vim/lsp/builtin_callbacks.lua | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/builtin_callbacks.lua b/runtime/lua/vim/lsp/builtin_callbacks.lua
index a5e1162d02..2229547f20 100644
--- a/runtime/lua/vim/lsp/builtin_callbacks.lua
+++ b/runtime/lua/vim/lsp/builtin_callbacks.lua
@@ -80,11 +80,11 @@ end
 local function focusable_popup()
   local popup_win
   return function(winnr)
-    if popup_win and nvim.win_is_valid(popup_win) then
-      if nvim.get_current_win() == popup_win then
-        nvim.ex.wincmd "p"
+    if popup_win and api.nvim_win_is_valid(popup_win) then
+      if api.nvim_get_current_win() == popup_win then
+        api.nvim_command("wincmd p")
       else
-        nvim.set_current_win(popup_win)
+        api.nvim_set_current_win(popup_win)
       end
       return
     end
-- 
cgit 


From c83380cf80561d45c067db5e70c7275eda7671af Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 14:21:57 -0800
Subject: Add lsp.buf and hover implementation.

---
 runtime/lua/vim/lsp/buf.lua | 85 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 runtime/lua/vim/lsp/buf.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
new file mode 100644
index 0000000000..6398bcca74
--- /dev/null
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -0,0 +1,85 @@
+local validate = vim.validate
+local api = vim.api
+local util = require 'vim.lsp.util'
+local protocol = require 'vim.lsp.protocol'
+
+local M = {}
+
+local function resolve_bufnr(bufnr)
+  validate { bufnr = { bufnr, 'n', true } }
+  if bufnr == nil or bufnr == 0 then
+    return api.nvim_get_current_buf()
+  end
+  return bufnr
+end
+
+local function ok_or_nil(status, ...)
+	if not status then return end
+	return ...
+end
+local function npcall(fn, ...)
+	return ok_or_nil(pcall(fn, ...))
+end
+
+local function find_window_by_var(name, value)
+	for _, win in ipairs(api.nvim_list_wins()) do
+		if npcall(api.nvim_win_get_var, win, name) == value then
+			return win
+		end
+	end
+end
+
+local hover_window_tag = 'lsp_hover'
+function M.hover(bufnr)
+	if npcall(api.nvim_win_get_var, 0, hover_window_tag) then
+		api.nvim_command("wincmd p")
+		return
+	end
+
+	bufnr = resolve_bufnr(bufnr)
+	do
+		local win = find_window_by_var(hover_window_tag, bufnr)
+		if win then
+			api.nvim_set_current_win(win)
+			return
+		end
+	end
+	local params = protocol.make_text_document_position_params()
+	vim.lsp.buf_request(bufnr, 'textDocument/hover', params, function(_, _, result, _)
+		if result == nil or vim.tbl_isempty(result) then
+			return
+		end
+
+		if result.contents ~= nil then
+			local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+			markdown_lines = util.trim_empty_lines(markdown_lines)
+			if vim.tbl_isempty(markdown_lines) then
+				markdown_lines = { 'No information available' }
+			end
+			local filetype = util.try_trim_markdown_code_blocks(markdown_lines)
+			local _, winnr = util.open_floating_preview(markdown_lines, filetype)
+			api.nvim_win_set_var(winnr, hover_window_tag, bufnr)
+		end
+	end)
+end
+
+function M.signature_help()
+end
+
+function M.declaration()
+end
+
+function M.type_definition()
+end
+
+function M.implementation()
+end
+
+-- TODO(ashkan) ?
+function M.completion()
+end
+
+function M.range_formatting()
+end
+
+return M
-- 
cgit 


From 2d580756ca707945c01703d404e10f4bf412a72c Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 15:35:18 -0800
Subject: Add everything to lsp.buf and get rid of autoload.

---
 runtime/lua/vim/lsp/buf.lua  | 161 ++++++++++++++++++++++++++++++++++++-------
 runtime/lua/vim/lsp/util.lua |  88 +++++++++++++++++------
 2 files changed, 204 insertions(+), 45 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 6398bcca74..5f54196dcc 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -1,7 +1,9 @@
 local validate = vim.validate
 local api = vim.api
+local vfn = vim.fn
 local util = require 'vim.lsp.util'
 local protocol = require 'vim.lsp.protocol'
+local log = require 'vim.lsp.log'
 
 local M = {}
 
@@ -29,54 +31,165 @@ local function find_window_by_var(name, value)
 	end
 end
 
-local hover_window_tag = 'lsp_hover'
-function M.hover(bufnr)
-	if npcall(api.nvim_win_get_var, 0, hover_window_tag) then
-		api.nvim_command("wincmd p")
-		return
+local function request(method, params, callback)
+	--	TODO(ashkan) enable this.
+	--	callback = vim.lsp.default_callback[method] or callback
+	validate {
+		method = {method, 's'};
+		callback = {callback, 'f'};
+	}
+	return vim.lsp.buf_request(0, method, params, function(err, _, result, client_id)
+		if err then error(tostring(err)) end
+		return callback(err, method, result, client_id)
+	end)
+end
+
+local function focusable_preview(method, params, fn)
+	if npcall(api.nvim_win_get_var, 0, method) then
+		return api.nvim_command("wincmd p")
 	end
 
-	bufnr = resolve_bufnr(bufnr)
+	local bufnr = api.nvim_get_current_buf()
 	do
-		local win = find_window_by_var(hover_window_tag, bufnr)
+		local win = find_window_by_var(method, bufnr)
 		if win then
-			api.nvim_set_current_win(win)
-			return
+			return api.nvim_set_current_win(win)
 		end
 	end
-	local params = protocol.make_text_document_position_params()
-	vim.lsp.buf_request(bufnr, 'textDocument/hover', params, function(_, _, result, _)
-		if result == nil or vim.tbl_isempty(result) then
-			return
+	return request(method, params, function(_, _, result, _)
+			-- TODO(ashkan) could show error in preview...
+		local lines, filetype, opts = fn(result)
+		if lines then
+			local _, winnr = util.open_floating_preview(lines, filetype, opts)
+			api.nvim_win_set_var(winnr, method, bufnr)
 		end
+	end)
+end
+
+function M.hover()
+	local params = protocol.make_text_document_position_params()
+	focusable_preview('textDocument/hover', params, function(result)
+		if not (result and result.contents) then return end
 
-		if result.contents ~= nil then
-			local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
-			markdown_lines = util.trim_empty_lines(markdown_lines)
-			if vim.tbl_isempty(markdown_lines) then
-				markdown_lines = { 'No information available' }
-			end
-			local filetype = util.try_trim_markdown_code_blocks(markdown_lines)
-			local _, winnr = util.open_floating_preview(markdown_lines, filetype)
-			api.nvim_win_set_var(winnr, hover_window_tag, bufnr)
+		local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+		markdown_lines = util.trim_empty_lines(markdown_lines)
+		if vim.tbl_isempty(markdown_lines) then
+			return { 'No information available' }
 		end
+		return markdown_lines, util.try_trim_markdown_code_blocks(markdown_lines)
 	end)
 end
 
-function M.signature_help()
+function M.peek_definition()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/peekDefinition', params, function(_, _, result, _)
+		if not (result and result[1]) then return end
+		local loc = result[1]
+		local bufnr = vim.uri_to_bufnr(loc.uri) or error("couldn't find file "..tostring(loc.uri))
+		local start = loc.range.start
+		local finish = loc.range["end"]
+		util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
+		local headbuf = util.open_floating_preview({"Peek:"}, nil, {
+			offset_y = -(finish.line - start.line);
+			width = finish.character - start.character + 2;
+		})
+		-- TODO(ashkan) change highlight group?
+		api.nvim_buf_add_highlight(headbuf, -1, 'Keyword', 0, -1)
+	end)
+end
+
+
+local function update_tagstack()
+  local bufnr = api.nvim_get_current_buf()
+  local line = vfn.line('.')
+  local col = vfn.col('.')
+  local tagname = vfn.expand('<cWORD>')
+  local item = { bufnr = bufnr, from = { bufnr, line, col, 0 }, tagname = tagname }
+  local winid = vfn.win_getid()
+  local tagstack = vfn.gettagstack(winid)
+  local action
+  if tagstack.length == tagstack.curidx then
+    action = 'r'
+    tagstack.items[tagstack.curidx] = item
+  elseif tagstack.length > tagstack.curidx then
+    action = 'r'
+    if tagstack.curidx > 1 then
+      tagstack.items = table.insert(tagstack.items[tagstack.curidx - 1], item)
+    else
+      tagstack.items = { item }
+    end
+  else
+    action = 'a'
+    tagstack.items = { item }
+  end
+  tagstack.curidx = tagstack.curidx + 1
+  vfn.settagstack(winid, tagstack, action)
+end
+local function handle_location(result)
+  -- We can sometimes get a list of locations, so set the first value as the
+  -- only value we want to handle
+  -- TODO(ashkan) was this correct^? We could use location lists.
+  if result[1] ~= nil then
+    result = result[1]
+  end
+  if result.uri == nil then
+    api.nvim_err_writeln('[LSP] Could not find a valid location')
+    return
+  end
+  local result_file = vim.uri_to_fname(result.uri)
+  local bufnr = vfn.bufadd(result_file)
+  update_tagstack()
+  api.nvim_set_current_buf(bufnr)
+  local start = result.range.start
+  api.nvim_win_set_cursor(0, {start.line + 1, start.character})
+  return true
+end
+local function location_callback(_, method, result)
+  if result == nil or vim.tbl_isempty(result) then
+    local _ = log.info() and log.info(method, 'No location found')
+    return nil
+  end
+  return handle_location(result)
 end
 
 function M.declaration()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/declaration', params, location_callback)
+end
+
+function M.definition()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/definition', params, location_callback)
 end
 
 function M.type_definition()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/typeDefinition', params, location_callback)
 end
 
 function M.implementation()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/implementation', params, location_callback)
+end
+
+function M.signature_help()
+	local params = protocol.make_text_document_position_params()
+	request('textDocument/signatureHelp', params, location_callback)
 end
 
 -- TODO(ashkan) ?
-function M.completion()
+function M.completion(context)
+	local params = protocol.make_text_document_position_params()
+	params.context = context
+	return request('textDocument/completion', params, function(_, _, result)
+		if vim.tbl_isempty(result or {}) then return end
+		local row, col = unpack(api.nvim_win_get_cursor(0))
+		local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
+		local line_to_cursor = line:sub(col+1)
+
+		local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
+		vim.fn.complete(col, matches)
+	end)
 end
 
 function M.range_formatting()
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 707e2d0d3b..13c83fefd6 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -261,32 +261,27 @@ function M.open_floating_preview(contents, filetype, opts)
     filetype = { filetype, 's', true };
     opts = { opts, 't', true };
   }
-
-  -- Don't modify our inputs.
-  contents = vim.deepcopy(contents)
+  opts = opts or {}
 
   -- Trim empty lines from the end.
-  for i = #contents, 1, -1 do
-    if #contents[i] == 0 then
-      table.remove(contents)
-    else
-      break
+  contents = M.trim_empty_lines(contents)
+
+  local width = opts.width
+  local height = opts.height or #contents
+  if not width then
+    width = 0
+    for i, line in ipairs(contents) do
+      -- Clean up the input and add left pad.
+      line = " "..line:gsub("\r", "")
+      -- TODO(ashkan) use nvim_strdisplaywidth if/when that is introduced.
+      local line_width = vim.fn.strdisplaywidth(line)
+      width = math.max(line_width, width)
+      contents[i] = line
     end
+    -- Add right padding of 1 each.
+    width = width + 1
   end
 
-  local width = 0
-  local height = #contents
-  for i, line in ipairs(contents) do
-    -- Clean up the input and add left pad.
-    line = " "..line:gsub("\r", "")
-    -- TODO(ashkan) use nvim_strdisplaywidth if/when that is introduced.
-    local line_width = vim.fn.strdisplaywidth(line)
-    width = math.max(line_width, width)
-    contents[i] = line
-  end
-  -- Add right padding of 1 each.
-  width = width + 1
-
   local floating_bufnr = api.nvim_create_buf(false, true)
   if filetype then
     api.nvim_buf_set_option(floating_bufnr, 'filetype', filetype)
@@ -556,5 +551,56 @@ function M.buf_loclist(bufnr, locations)
   vim.fn.setloclist(targetwin, items, ' ', 'Language Server')
 end
 
+-- Remove empty lines from the beginning and end.
+function M.trim_empty_lines(lines)
+  local result = {}
+  local start = 1
+  for i = 1, #lines do
+    if #lines[i] > 0 then
+      start = i
+      break
+    end
+  end
+  local finish = 1
+  for i = #lines, 1, -1 do
+    if #lines[i] > 0 then
+      finish = i
+      break
+    end
+  end
+  -- TODO(ashkan) use tbl_slice.
+  for i = start, finish do
+    table.insert(result, lines[i])
+  end
+  return result
+end
+
+-- Accepts markdown lines and tries to reduce it to a filetype if it is
+-- just a single code block.
+-- Note: This modifies the input.
+--
+-- Returns: filetype or 'markdown' if it was unchanged.
+function M.try_trim_markdown_code_blocks(lines)
+  local language_id = lines[1]:match("^```(.*)")
+  if language_id then
+    local has_inner_code_fence = false
+    for i = 2, (#lines - 1) do
+      local line = lines[i]
+      if line:sub(1,3) == '```' then
+        has_inner_code_fence = true
+        break
+      end
+    end
+    -- No inner code fences + starting with code fence = hooray.
+    if not has_inner_code_fence then
+      table.remove(lines, 1)
+      table.remove(lines)
+      return language_id
+    end
+  end
+  return 'markdown'
+end
+
+
 return M
 -- vim:sw=2 ts=2 et
-- 
cgit 


From a4b7004f489030d9ee7e3bbfc156ab540744279b Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:03:32 -0800
Subject: Move everything to buf & default_callbacks

- Rename builtin_callbacks to default_callbacks and slightly change its
semantics:
  - No longer contains the default implementations. Instead, any
  default_callbacks will be used in preference for our .buf methods.
  - Add this to the docs.
---
 runtime/lua/vim/lsp.lua                   | 137 +-----------
 runtime/lua/vim/lsp/buf.lua               |  86 +++++++-
 runtime/lua/vim/lsp/builtin_callbacks.lua | 344 ------------------------------
 runtime/lua/vim/lsp/default_callbacks.lua |  57 +++++
 runtime/lua/vim/lsp/protocol.lua          |   1 -
 5 files changed, 147 insertions(+), 478 deletions(-)
 delete mode 100644 runtime/lua/vim/lsp/builtin_callbacks.lua
 create mode 100644 runtime/lua/vim/lsp/default_callbacks.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 4724ff0281..44909a85ee 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1,4 +1,4 @@
-local builtin_callbacks = require 'vim.lsp.builtin_callbacks'
+local default_callbacks = require 'vim.lsp.default_callbacks'
 local log = require 'vim.lsp.log'
 local lsp_rpc = require 'vim.lsp.rpc'
 local protocol = require 'vim.lsp.protocol'
@@ -12,7 +12,8 @@ local validate = vim.validate
 
 local lsp = {
   protocol = protocol;
-  builtin_callbacks = builtin_callbacks;
+  default_callbacks = default_callbacks;
+  buf = require'vim.lsp.buf';
   util = util;
   -- Allow raw RPC access.
   rpc = lsp_rpc;
@@ -283,7 +284,7 @@ function lsp.start_client(config)
 
   local client_id = next_client_id()
 
-  local callbacks = tbl_extend("keep", config.callbacks or {}, builtin_callbacks)
+  local callbacks = tbl_extend("keep", config.callbacks or {}, default_callbacks)
   -- Copy metatable if it has one.
   if config.callbacks and config.callbacks.__metatable then
     setmetatable(callbacks, getmetatable(config.callbacks))
@@ -869,134 +870,8 @@ function lsp.omnifunc(findstart, base)
   end
 end
 
----
---- FileType based configuration utility
----
-
-local all_filetype_configs = {}
-
--- Lookup a filetype config client by its name.
-function lsp.get_filetype_client_by_name(name)
-  local config = all_filetype_configs[name]
-  if config.client_id then
-    return active_clients[config.client_id]
-  end
-end
-
-local function start_filetype_config(config)
-  config.client_id = lsp.start_client(config)
-  nvim_command(string.format(
-    "autocmd FileType %s silent lua vim.lsp.buf_attach_client(0, %d)",
-    table.concat(config.filetypes, ','),
-    config.client_id))
-  return config.client_id
-end
-
--- Easy configuration option for common LSP use-cases.
--- This will lazy initialize the client when the filetypes specified are
--- encountered and attach to those buffers.
---
--- The configuration options are the same as |vim.lsp.start_client()|, but
--- with a few additions and distinctions:
---
--- Additional parameters:
--- - filetype: {string} or {list} of filetypes to attach to.
--- - name: A unique string among all other servers configured with
--- |vim.lsp.add_filetype_config|.
---
--- Differences:
--- - root_dir: will default to |getcwd()|
---
-function lsp.add_filetype_config(config)
-  -- Additional defaults.
-  -- Keep a copy of the user's input for debugging reasons.
-  local user_config = config
-  config = tbl_extend("force", {}, user_config)
-  config.root_dir = config.root_dir or uv.cwd()
-  -- Validate config.
-  validate_client_config(config)
-  validate {
-    name = { config.name, 's' };
-  }
-  assert(config.filetype, "config must have 'filetype' key")
-
-  local filetypes
-  if type(config.filetype) == 'string' then
-    filetypes = { config.filetype }
-  elseif type(config.filetype) == 'table' then
-    filetypes = config.filetype
-    assert(not tbl_isempty(filetypes), "config.filetype must not be an empty table")
-  else
-    error("config.filetype must be a string or a list of strings")
-  end
-
-  if all_filetype_configs[config.name] then
-    -- If the client exists, then it is likely that they are doing some kind of
-    -- reload flow, so let's not throw an error here.
-    if all_filetype_configs[config.name].client_id then
-      -- TODO log here? It might be unnecessarily annoying.
-      return
-    end
-    error(string.format('A configuration with the name %q already exists. They must be unique', config.name))
-  end
-
-  all_filetype_configs[config.name] = tbl_extend("keep", config, {
-    client_id = nil;
-    filetypes = filetypes;
-    user_config = user_config;
-  })
-
-  nvim_command(string.format(
-    "autocmd FileType %s ++once silent lua vim.lsp._start_filetype_config_client(%q)",
-    table.concat(filetypes, ','),
-    config.name))
-end
-
--- Create a copy of an existing configuration, and override config with values
--- from new_config.
--- This is useful if you wish you create multiple LSPs with different root_dirs
--- or other use cases.
---
--- You can specify a new unique name, but if you do not, a unique name will be
--- created like `name-dup_count`.
---
--- existing_name: the name of the existing config to copy.
--- new_config: the new configuration options. @see |vim.lsp.start_client()|.
--- @returns string the new name.
-function lsp.copy_filetype_config(existing_name, new_config)
-  local config = all_filetype_configs[existing_name]
-      or error(string.format("Configuration with name %q doesn't exist", existing_name))
-  config = tbl_extend("force", config, new_config or {})
-  config.client_id = nil
-  config.original_config_name = existing_name
-
-  -- If the user didn't rename it, we will.
-  if config.name == existing_name then
-    -- Create a new, unique name.
-    local duplicate_count = 0
-    for _, conf in pairs(all_filetype_configs) do
-      if conf.original_config_name == existing_name then
-        duplicate_count = duplicate_count + 1
-      end
-    end
-    config.name = string.format("%s-%d", existing_name, duplicate_count + 1)
-  end
-  print("New config name:", config.name)
-  lsp.add_filetype_config(config)
-  return config.name
-end
-
--- Autocmd handler to actually start the client when an applicable filetype is
--- encountered.
-function lsp._start_filetype_config_client(name)
-  local config = all_filetype_configs[name]
-  -- If it exists and is running, don't make it again.
-  if config.client_id and active_clients[config.client_id] then
-    -- TODO log here?
-    return
-  end
-  lsp.buf_attach_client(0, start_filetype_config(config))
-  return config.client_id
+function lsp.client_is_stopped(client_id)
+  return active_clients[client_id] == nil
 end
 
 ---
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 5f54196dcc..e8a38aa6ef 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -33,7 +33,7 @@ end
 
 local function request(method, params, callback)
 	--	TODO(ashkan) enable this.
-	--	callback = vim.lsp.default_callback[method] or callback
+	--	callback = vim.lsp.default_callbacks[method] or callback
 	validate {
 		method = {method, 's'};
 		callback = {callback, 'f'};
@@ -172,9 +172,78 @@ function M.implementation()
 	request('textDocument/implementation', params, location_callback)
 end
 
+--- Convert SignatureHelp response to preview contents.
+-- https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_signatureHelp
+local function signature_help_to_preview_contents(input)
+  if not input.signatures then
+    return
+  end
+  --The active signature. If omitted or the value lies outside the range of
+  --`signatures` the value defaults to zero or is ignored if `signatures.length
+  --=== 0`. Whenever possible implementors should make an active decision about
+  --the active signature and shouldn't rely on a default value.
+  local contents = {}
+  local active_signature = input.activeSignature or 0
+  -- If the activeSignature is not inside the valid range, then clip it.
+  if active_signature >= #input.signatures then
+    active_signature = 0
+  end
+  local signature = input.signatures[active_signature + 1]
+  if not signature then
+    return
+  end
+  vim.list_extend(contents, split_lines(signature.label))
+  if signature.documentation then
+    util.convert_input_to_markdown_lines(signature.documentation, contents)
+  end
+  if input.parameters then
+    local active_parameter = input.activeParameter or 0
+    -- If the activeParameter is not inside the valid range, then clip it.
+    if active_parameter >= #input.parameters then
+      active_parameter = 0
+    end
+    local parameter = signature.parameters and signature.parameters[active_parameter]
+    if parameter then
+      --[=[
+      --Represents a parameter of a callable-signature. A parameter can
+      --have a label and a doc-comment.
+      interface ParameterInformation {
+        --The label of this parameter information.
+        --
+        --Either a string or an inclusive start and exclusive end offsets within its containing
+        --signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
+        --string representation as `Position` and `Range` does.
+        --
+        --*Note*: a label of type string should be a substring of its containing signature label.
+        --Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+        label: string | [number, number];
+        --The human-readable doc-comment of this parameter. Will be shown
+        --in the UI but can be omitted.
+        documentation?: string | MarkupContent;
+      }
+      --]=]
+      -- TODO highlight parameter
+      if parameter.documentation then
+        util.convert_input_to_markdown_lines(parameter.documentation, contents)
+      end
+    end
+  end
+  return contents
+end
+
 function M.signature_help()
 	local params = protocol.make_text_document_position_params()
-	request('textDocument/signatureHelp', params, location_callback)
+	focusable_preview('textDocument/signatureHelp', params, function(result)
+		if not (result and result.signatures and result.signatures[1]) then return end
+
+		-- TODO show empty popup when signatures is empty?
+		local lines = signature_help_to_preview_contents(result)
+		lines = util.trim_empty_lines(lines)
+		if vim.tbl_isempty(lines) then
+			return { 'No signature available' }
+		end
+		return lines, util.try_trim_markdown_code_blocks(lines)
+	end)
 end
 
 -- TODO(ashkan) ?
@@ -195,4 +264,17 @@ end
 function M.range_formatting()
 end
 
+function M.rename(new_name)
+	-- TODO(ashkan) use prepareRename
+	-- * result: [`Range`](#range) \| `{ range: Range, placeholder: string }` \| `null` describing the range of the string to rename and optionally a placeholder text of the string content to be renamed. If `null` is returned then it is deemed that a 'textDocument/rename' request is not valid at the given position.
+	local params = protocol.make_text_document_position_params()
+	new_name = new_name or npcall(vfn.input, "New Name: ")
+	if not (new_name and #new_name > 0) then return end
+	params.newName = new_name
+	request('textDocument/rename', params, function(_, _, result)
+		if not result then return end
+		util.workspace_apply_workspace_edit(result)
+	end)
+end
+
 return M
diff --git a/runtime/lua/vim/lsp/builtin_callbacks.lua b/runtime/lua/vim/lsp/builtin_callbacks.lua
deleted file mode 100644
index 2229547f20..0000000000
--- a/runtime/lua/vim/lsp/builtin_callbacks.lua
+++ /dev/null
@@ -1,344 +0,0 @@
---- Implements the following default callbacks:
---
--- vim.api.nvim_buf_set_lines(0, 0, 0, false, vim.tbl_keys(vim.lsp.builtin_callbacks))
---
-
--- textDocument/completion
--- textDocument/declaration
--- textDocument/definition
--- textDocument/hover
--- textDocument/implementation
--- textDocument/publishDiagnostics
--- textDocument/rename
--- textDocument/signatureHelp
--- textDocument/typeDefinition
--- TODO codeLens/resolve
--- TODO completionItem/resolve
--- TODO documentLink/resolve
--- TODO textDocument/codeAction
--- TODO textDocument/codeLens
--- TODO textDocument/documentHighlight
--- TODO textDocument/documentLink
--- TODO textDocument/documentSymbol
--- TODO textDocument/formatting
--- TODO textDocument/onTypeFormatting
--- TODO textDocument/rangeFormatting
--- TODO textDocument/references
--- window/logMessage
--- window/showMessage
-
-local log = require 'vim.lsp.log'
-local protocol = require 'vim.lsp.protocol'
-local util = require 'vim.lsp.util'
-local api = vim.api
-
-local function split_lines(value)
-  return vim.split(value, '\n', true)
-end
-
-local builtin_callbacks = {}
-
--- textDocument/completion
--- https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
-builtin_callbacks['textDocument/completion'] = function(_, _, result)
-  if not result or vim.tbl_isempty(result) then
-    return
-  end
-  local pos = api.nvim_win_get_cursor(0)
-  local row, col = pos[1], pos[2]
-  local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
-  local line_to_cursor = line:sub(col+1)
-
-  local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
-  local match_result = vim.fn.matchstrpos(line_to_cursor, '\\k\\+$')
-  local match_start, match_finish = match_result[2], match_result[3]
-
-  vim.fn.complete(col + 1 - (match_finish - match_start), matches)
-end
-
--- textDocument/rename
-builtin_callbacks['textDocument/rename'] = function(_, _, result)
-  if not result then return end
-  util.workspace_apply_workspace_edit(result)
-end
-
-builtin_callbacks['textDocument/publishDiagnostics'] = function(_, _, result)
-  if not result then return end
-  local uri = result.uri
-  local bufnr = vim.uri_to_bufnr(uri)
-  if not bufnr then
-    api.nvim_err_writeln(string.format("LSP.publishDiagnostics: Couldn't find buffer for %s", uri))
-    return
-  end
-  util.buf_clear_diagnostics(bufnr)
-  util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
-  util.buf_diagnostics_underline(bufnr, result.diagnostics)
-  util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
-  -- util.buf_loclist(bufnr, result.diagnostics)
-end
-
-local function focusable_popup()
-  local popup_win
-  return function(winnr)
-    if popup_win and api.nvim_win_is_valid(popup_win) then
-      if api.nvim_get_current_win() == popup_win then
-        api.nvim_command("wincmd p")
-      else
-        api.nvim_set_current_win(popup_win)
-      end
-      return
-    end
-    popup_win = winnr
-  end
-end
-
-local hover_popup = focusable_popup()
-
-local function trim_empty_lines(lines)
-  local result = {}
-  for _, line in ipairs(lines) do
-    if #line > 0 then
-      table.insert(result, line)
-    end
-  end
-  return result
-end
-
--- Accepts markdown lines and tries to reduce it to a filetype if it is
--- just a single code block.
-local function try_trim_code_blocks(lines)
-  local language_id = lines[1]:match("^```(.*)")
-  if language_id then
-    local has_inner_code_fence = false
-    for i = 2, (#lines - 1) do
-      local line = lines[i]
-      if line:sub(1,3) == '```' then
-        has_inner_code_fence = true
-        break
-      end
-    end
-    -- No inner code fences + starting with code fence = hooray.
-    if not has_inner_code_fence then
-      table.remove(lines, 1)
-      table.remove(lines)
-      return lines, language_id
-    end
-  end
-  return lines, 'markdown'
-end
-
--- textDocument/hover
--- https://microsoft.github.io/language-server-protocol/specification#textDocument_hover
--- @params MarkedString | MarkedString[] | MarkupContent
-builtin_callbacks['textDocument/hover'] = function(_, _, result)
-  if result == nil or vim.tbl_isempty(result) then
-    return
-  end
-
-  if result.contents ~= nil then
-    local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
-    markdown_lines = trim_empty_lines(markdown_lines)
-    if vim.tbl_isempty(markdown_lines) then
-      markdown_lines = { 'No information available' }
-    end
-    local _, winnr = util.open_floating_preview(try_trim_code_blocks(markdown_lines))
-    hover_popup(winnr)
-  end
-end
-
-builtin_callbacks['textDocument/peekDefinition'] = function(_, _, result)
-  if result == nil or vim.tbl_isempty(result) then return end
-  -- TODO(ashkan) what to do with multiple locations?
-  result = result[1]
-  local bufnr = vim.uri_to_bufnr(result.uri)
-  assert(bufnr)
-  local start = result.range.start
-  local finish = result.range["end"]
-  util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
-  util.open_floating_preview({"*Peek:*", string.rep(" ", finish.character - start.character + 1) }, 'markdown', { offset_y = -(finish.line - start.line) })
-end
-
---- Convert SignatureHelp response to preview contents.
--- https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_signatureHelp
-local function signature_help_to_preview_contents(input)
-  if not input.signatures then
-    return
-  end
-  --The active signature. If omitted or the value lies outside the range of
-  --`signatures` the value defaults to zero or is ignored if `signatures.length
-  --=== 0`. Whenever possible implementors should make an active decision about
-  --the active signature and shouldn't rely on a default value.
-  local contents = {}
-  local active_signature = input.activeSignature or 0
-  -- If the activeSignature is not inside the valid range, then clip it.
-  if active_signature >= #input.signatures then
-    active_signature = 0
-  end
-  local signature = input.signatures[active_signature + 1]
-  if not signature then
-    return
-  end
-  vim.list_extend(contents, split_lines(signature.label))
-  if signature.documentation then
-    util.convert_input_to_markdown_lines(signature.documentation, contents)
-  end
-  if input.parameters then
-    local active_parameter = input.activeParameter or 0
-    -- If the activeParameter is not inside the valid range, then clip it.
-    if active_parameter >= #input.parameters then
-      active_parameter = 0
-    end
-    local parameter = signature.parameters and signature.parameters[active_parameter]
-    if parameter then
-      --[=[
-      --Represents a parameter of a callable-signature. A parameter can
-      --have a label and a doc-comment.
-      interface ParameterInformation {
-        --The label of this parameter information.
-        --
-        --Either a string or an inclusive start and exclusive end offsets within its containing
-        --signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
-        --string representation as `Position` and `Range` does.
-        --
-        --*Note*: a label of type string should be a substring of its containing signature label.
-        --Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
-        label: string | [number, number];
-        --The human-readable doc-comment of this parameter. Will be shown
-        --in the UI but can be omitted.
-        documentation?: string | MarkupContent;
-      }
-      --]=]
-      -- TODO highlight parameter
-      if parameter.documentation then
-        util.convert_input_to_markdown_lines(parameter.documentation, contents)
-      end
-    end
-  end
-  return contents
-end
-
--- textDocument/signatureHelp
--- https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp
-builtin_callbacks['textDocument/signatureHelp'] = function(_, _, result)
-  if result == nil or vim.tbl_isempty(result) then
-    return
-  end
-
-  -- TODO show empty popup when signatures is empty?
-  if #result.signatures > 0 then
-    local markdown_lines = signature_help_to_preview_contents(result)
-    if vim.tbl_isempty(markdown_lines) then
-      markdown_lines = { 'No signature available' }
-    end
-    util.open_floating_preview(markdown_lines, 'markdown')
-  end
-end
-
-local function update_tagstack()
-  local bufnr = api.nvim_get_current_buf()
-  local line = vim.fn.line('.')
-  local col = vim.fn.col('.')
-  local tagname = vim.fn.expand('<cWORD>')
-  local item = { bufnr = bufnr, from = { bufnr, line, col, 0 }, tagname = tagname }
-  local winid = vim.fn.win_getid()
-  local tagstack = vim.fn.gettagstack(winid)
-
-  local action
-
-  if tagstack.length == tagstack.curidx then
-    action = 'r'
-    tagstack.items[tagstack.curidx] = item
-  elseif tagstack.length > tagstack.curidx then
-    action = 'r'
-    if tagstack.curidx > 1 then
-      tagstack.items = table.insert(tagstack.items[tagstack.curidx - 1], item)
-    else
-      tagstack.items = { item }
-    end
-  else
-    action = 'a'
-    tagstack.items = { item }
-  end
-
-  tagstack.curidx = tagstack.curidx + 1
-  vim.fn.settagstack(winid, tagstack, action)
-end
-
-local function handle_location(result)
-  -- We can sometimes get a list of locations, so set the first value as the
-  -- only value we want to handle
-  -- TODO(ashkan) was this correct^? We could use location lists.
-  if result[1] ~= nil then
-    result = result[1]
-  end
-  if result.uri == nil then
-    api.nvim_err_writeln('[LSP] Could not find a valid location')
-    return
-  end
-  local result_file = vim.uri_to_fname(result.uri)
-  local bufnr = vim.fn.bufadd(result_file)
-  update_tagstack()
-  api.nvim_set_current_buf(bufnr)
-  local start = result.range.start
-  api.nvim_win_set_cursor(0, {start.line + 1, start.character})
-end
-
-local function location_callback(_, method, result)
-  if result == nil or vim.tbl_isempty(result) then
-    local _ = log.info() and log.info(method, 'No location found')
-    return nil
-  end
-  handle_location(result)
-  return true
-end
-
-local location_callbacks = {
-  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_declaration
-  'textDocument/declaration';
-  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_definition
-  'textDocument/definition';
-  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_implementation
-  'textDocument/implementation';
-  -- https://microsoft.github.io/language-server-protocol/specification#textDocument_typeDefinition
-  'textDocument/typeDefinition';
-}
-
-for _, location_method in ipairs(location_callbacks) do
-  builtin_callbacks[location_method] = location_callback
-end
-
-local function log_message(_, _, result, client_id)
-  local message_type = result.type
-  local message = result.message
-  local client = vim.lsp.get_client_by_id(client_id)
-  local client_name = client and client.name or string.format("id=%d", client_id)
-  if not client then
-    api.nvim_err_writeln(string.format("LSP[%s] client has shut down after sending the message", client_name))
-  end
-  if message_type == protocol.MessageType.Error then
-    -- Might want to not use err_writeln,
-    -- but displaying a message with red highlights or something
-    api.nvim_err_writeln(string.format("LSP[%s] %s", client_name, message))
-  else
-    local message_type_name = protocol.MessageType[message_type]
-    api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
-  end
-  return result
-end
-
-builtin_callbacks['window/showMessage'] = log_message
-builtin_callbacks['window/logMessage'] = log_message
-
--- Add boilerplate error validation and logging for all of these.
-for k, fn in pairs(builtin_callbacks) do
-  builtin_callbacks[k] = function(err, method, params, client_id)
-    local _ = log.debug() and log.debug('builtin_callback', method, { params = params, client_id = client_id, err = err })
-    if err then
-      error(tostring(err))
-    end
-    return fn(err, method, params, client_id)
-  end
-end
-
-return builtin_callbacks
--- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
new file mode 100644
index 0000000000..63e62075b4
--- /dev/null
+++ b/runtime/lua/vim/lsp/default_callbacks.lua
@@ -0,0 +1,57 @@
+local log = require 'vim.lsp.log'
+local protocol = require 'vim.lsp.protocol'
+local util = require 'vim.lsp.util'
+local api = vim.api
+
+local M = {}
+
+M['textDocument/publishDiagnostics'] = function(_, _, result)
+  if not result then return end
+  local uri = result.uri
+  local bufnr = vim.uri_to_bufnr(uri)
+  if not bufnr then
+    api.nvim_err_writeln(string.format("LSP.publishDiagnostics: Couldn't find buffer for %s", uri))
+    return
+  end
+  util.buf_clear_diagnostics(bufnr)
+  util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
+  util.buf_diagnostics_underline(bufnr, result.diagnostics)
+  util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
+  -- util.buf_loclist(bufnr, result.diagnostics)
+end
+
+local function log_message(_, _, result, client_id)
+  local message_type = result.type
+  local message = result.message
+  local client = vim.lsp.get_client_by_id(client_id)
+  local client_name = client and client.name or string.format("id=%d", client_id)
+  if not client then
+    api.nvim_err_writeln(string.format("LSP[%s] client has shut down after sending the message", client_name))
+  end
+  if message_type == protocol.MessageType.Error then
+    -- Might want to not use err_writeln,
+    -- but displaying a message with red highlights or something
+    api.nvim_err_writeln(string.format("LSP[%s] %s", client_name, message))
+  else
+    local message_type_name = protocol.MessageType[message_type]
+    api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
+  end
+  return result
+end
+
+M['window/showMessage'] = log_message
+M['window/logMessage'] = log_message
+
+-- Add boilerplate error validation and logging for all of these.
+for k, fn in pairs(M) do
+  M[k] = function(err, method, params, client_id)
+    local _ = log.debug() and log.debug('default_callback', method, { params = params, client_id = client_id, err = err })
+    if err then
+      error(tostring(err))
+    end
+    return fn(err, method, params, client_id)
+  end
+end
+
+return M
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/protocol.lua b/runtime/lua/vim/lsp/protocol.lua
index 1413a88ce2..1f51e7bef7 100644
--- a/runtime/lua/vim/lsp/protocol.lua
+++ b/runtime/lua/vim/lsp/protocol.lua
@@ -10,7 +10,6 @@ end
 
 --[=[
 -- Useful for interfacing with:
--- https://github.com/microsoft/language-server-protocol/blob/gh-pages/_specifications/specification-3-14.md
 -- https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.md
 function transform_schema_comments()
   nvim.command [[silent! '<,'>g/\/\*\*\|\*\/\|^$/d]]
-- 
cgit 


From 03eb88848c2bea6c0c1da7acc97754d6f47b5118 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:09:03 -0800
Subject: Change callback resolution to be dynamic.

This allows default_callbacks to be specified after client creation to
be considered. Also it simplifies the code.
---
 runtime/lua/vim/lsp.lua | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 44909a85ee..a284dd1ee7 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -284,19 +284,19 @@ function lsp.start_client(config)
 
   local client_id = next_client_id()
 
-  local callbacks = tbl_extend("keep", config.callbacks or {}, default_callbacks)
-  -- Copy metatable if it has one.
-  if config.callbacks and config.callbacks.__metatable then
-    setmetatable(callbacks, getmetatable(config.callbacks))
-  end
+  local callbacks = config.callbacks or {}
   local name = config.name or tostring(client_id)
   local log_prefix = string.format("LSP[%s]", name)
 
   local handlers = {}
 
+  local function resolve_callback(method)
+    return callbacks[method] or default_callbacks[method]
+  end
+
   function handlers.notification(method, params)
     local _ = log.debug() and log.debug('notification', method, params)
-    local callback = callbacks[method]
+    local callback = resolve_callback(method)
     if callback then
       -- Method name is provided here for convenience.
       callback(nil, method, params, client_id)
@@ -305,7 +305,7 @@ function lsp.start_client(config)
 
   function handlers.server_request(method, params)
     local _ = log.debug() and log.debug('server_request', method, params)
-    local callback = callbacks[method]
+    local callback = resolve_callback(method)
     if callback then
       local _ = log.debug() and log.debug("server_request: found callback for", method)
       return callback(nil, method, params, client_id)
@@ -316,7 +316,8 @@ function lsp.start_client(config)
 
   function handlers.on_error(code, err)
     local _ = log.error() and log.error(log_prefix, "on_error", { code = lsp.client_errors[code], err = err })
-    nvim_err_writeln(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
+    print(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
+--    nvim_err_writeln(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
     if config.on_error then
       local status, usererr = pcall(config.on_error, code, err)
       if not status then
@@ -440,7 +441,7 @@ function lsp.start_client(config)
   --- Checks capabilities before rpc.request-ing.
   function client.request(method, params, callback)
     if not callback then
-      callback = client.callbacks[method]
+      callback = resolve_callback(method)
         or error(string.format("request callback is empty and no default was found for client %s", client.name))
     end
     local _ = log.debug() and log.debug(log_prefix, "client.request", client_id, method, params, callback)
-- 
cgit 


From c40f8600d2418dfdfeacbba3efe11ae7c6c70ad3 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:16:13 -0800
Subject: Change error writer to not be annoying.

---
 runtime/lua/vim/lsp.lua     | 12 ++++++++----
 runtime/lua/vim/lsp/buf.lua |  7 ++++++-
 2 files changed, 14 insertions(+), 5 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index a284dd1ee7..1b9d788c43 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -27,6 +27,11 @@ local lsp = {
 -- TODO consider whether 'eol' or 'fixeol' should change the nvim_buf_get_lines that send.
 -- TODO improve handling of scratch buffers with LSP attached.
 
+local function err_message(...)
+  nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
+  nvim_command("redraw")
+end
+
 local function resolve_bufnr(bufnr)
   validate { bufnr = { bufnr, 'n', true } }
   if bufnr == nil or bufnr == 0 then
@@ -316,13 +321,12 @@ function lsp.start_client(config)
 
   function handlers.on_error(code, err)
     local _ = log.error() and log.error(log_prefix, "on_error", { code = lsp.client_errors[code], err = err })
-    print(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
---    nvim_err_writeln(string.format('%s: Error %s: %q', log_prefix, lsp.client_errors[code], vim.inspect(err)))
+    err_message(log_prefix, ': Error ', lsp.client_errors[code], ': ', vim.inspect(err))
     if config.on_error then
       local status, usererr = pcall(config.on_error, code, err)
       if not status then
         local _ = log.error() and log.error(log_prefix, "user on_error failed", { err = usererr })
-        nvim_err_writeln(log_prefix.." user on_error failed: "..tostring(usererr))
+        err_message(log_prefix, ' user on_error failed: ', tostring(usererr))
       end
     end
   end
@@ -434,7 +438,7 @@ function lsp.start_client(config)
   local function unsupported_method(method)
     local msg = "server doesn't support "..method
     local _ = log.warn() and log.warn(msg)
-    nvim_err_writeln(msg)
+    err_message(msg)
     return lsp.rpc_response_error(protocol.ErrorCodes.MethodNotFound, msg)
   end
 
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index e8a38aa6ef..ff045cbbfc 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -23,6 +23,11 @@ local function npcall(fn, ...)
 	return ok_or_nil(pcall(fn, ...))
 end
 
+local function err_message(...)
+  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
+  api.nvim_command("redraw")
+end
+
 local function find_window_by_var(name, value)
 	for _, win in ipairs(api.nvim_list_wins()) do
 		if npcall(api.nvim_win_get_var, win, name) == value then
@@ -133,7 +138,7 @@ local function handle_location(result)
     result = result[1]
   end
   if result.uri == nil then
-    api.nvim_err_writeln('[LSP] Could not find a valid location')
+    err_message('[LSP] Could not find a valid location')
     return
   end
   local result_file = vim.uri_to_fname(result.uri)
-- 
cgit 


From 1e16b3cf281bec73ccbd155dd11b2db048d1219a Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:16:36 -0800
Subject: Spaces not tabs.

---
 runtime/lua/vim/lsp/buf.lua | 201 ++++++++++++++++++++++----------------------
 1 file changed, 101 insertions(+), 100 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index ff045cbbfc..8b21370800 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -16,11 +16,11 @@ local function resolve_bufnr(bufnr)
 end
 
 local function ok_or_nil(status, ...)
-	if not status then return end
-	return ...
+  if not status then return end
+  return ...
 end
 local function npcall(fn, ...)
-	return ok_or_nil(pcall(fn, ...))
+  return ok_or_nil(pcall(fn, ...))
 end
 
 local function err_message(...)
@@ -29,78 +29,78 @@ local function err_message(...)
 end
 
 local function find_window_by_var(name, value)
-	for _, win in ipairs(api.nvim_list_wins()) do
-		if npcall(api.nvim_win_get_var, win, name) == value then
-			return win
-		end
-	end
+  for _, win in ipairs(api.nvim_list_wins()) do
+    if npcall(api.nvim_win_get_var, win, name) == value then
+      return win
+    end
+  end
 end
 
 local function request(method, params, callback)
-	--	TODO(ashkan) enable this.
-	--	callback = vim.lsp.default_callbacks[method] or callback
-	validate {
-		method = {method, 's'};
-		callback = {callback, 'f'};
-	}
-	return vim.lsp.buf_request(0, method, params, function(err, _, result, client_id)
-		if err then error(tostring(err)) end
-		return callback(err, method, result, client_id)
-	end)
+  --  TODO(ashkan) enable this.
+  --  callback = vim.lsp.default_callbacks[method] or callback
+  validate {
+    method = {method, 's'};
+    callback = {callback, 'f'};
+  }
+  return vim.lsp.buf_request(0, method, params, function(err, _, result, client_id)
+    if err then error(tostring(err)) end
+    return callback(err, method, result, client_id)
+  end)
 end
 
 local function focusable_preview(method, params, fn)
-	if npcall(api.nvim_win_get_var, 0, method) then
-		return api.nvim_command("wincmd p")
-	end
+  if npcall(api.nvim_win_get_var, 0, method) then
+    return api.nvim_command("wincmd p")
+  end
 
-	local bufnr = api.nvim_get_current_buf()
-	do
-		local win = find_window_by_var(method, bufnr)
-		if win then
-			return api.nvim_set_current_win(win)
-		end
-	end
-	return request(method, params, function(_, _, result, _)
-			-- TODO(ashkan) could show error in preview...
-		local lines, filetype, opts = fn(result)
-		if lines then
-			local _, winnr = util.open_floating_preview(lines, filetype, opts)
-			api.nvim_win_set_var(winnr, method, bufnr)
-		end
-	end)
+  local bufnr = api.nvim_get_current_buf()
+  do
+    local win = find_window_by_var(method, bufnr)
+    if win then
+      return api.nvim_set_current_win(win)
+    end
+  end
+  return request(method, params, function(_, _, result, _)
+      -- TODO(ashkan) could show error in preview...
+    local lines, filetype, opts = fn(result)
+    if lines then
+      local _, winnr = util.open_floating_preview(lines, filetype, opts)
+      api.nvim_win_set_var(winnr, method, bufnr)
+    end
+  end)
 end
 
 function M.hover()
-	local params = protocol.make_text_document_position_params()
-	focusable_preview('textDocument/hover', params, function(result)
-		if not (result and result.contents) then return end
+  local params = protocol.make_text_document_position_params()
+  focusable_preview('textDocument/hover', params, function(result)
+    if not (result and result.contents) then return end
 
-		local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
-		markdown_lines = util.trim_empty_lines(markdown_lines)
-		if vim.tbl_isempty(markdown_lines) then
-			return { 'No information available' }
-		end
-		return markdown_lines, util.try_trim_markdown_code_blocks(markdown_lines)
-	end)
+    local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+    markdown_lines = util.trim_empty_lines(markdown_lines)
+    if vim.tbl_isempty(markdown_lines) then
+      return { 'No information available' }
+    end
+    return markdown_lines, util.try_trim_markdown_code_blocks(markdown_lines)
+  end)
 end
 
 function M.peek_definition()
-	local params = protocol.make_text_document_position_params()
-	request('textDocument/peekDefinition', params, function(_, _, result, _)
-		if not (result and result[1]) then return end
-		local loc = result[1]
-		local bufnr = vim.uri_to_bufnr(loc.uri) or error("couldn't find file "..tostring(loc.uri))
-		local start = loc.range.start
-		local finish = loc.range["end"]
-		util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
-		local headbuf = util.open_floating_preview({"Peek:"}, nil, {
-			offset_y = -(finish.line - start.line);
-			width = finish.character - start.character + 2;
-		})
-		-- TODO(ashkan) change highlight group?
-		api.nvim_buf_add_highlight(headbuf, -1, 'Keyword', 0, -1)
-	end)
+  local params = protocol.make_text_document_position_params()
+  request('textDocument/peekDefinition', params, function(_, _, result, _)
+    if not (result and result[1]) then return end
+    local loc = result[1]
+    local bufnr = vim.uri_to_bufnr(loc.uri) or error("couldn't find file "..tostring(loc.uri))
+    local start = loc.range.start
+    local finish = loc.range["end"]
+    util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
+    local headbuf = util.open_floating_preview({"Peek:"}, nil, {
+      offset_y = -(finish.line - start.line);
+      width = finish.character - start.character + 2;
+    })
+    -- TODO(ashkan) change highlight group?
+    api.nvim_buf_add_highlight(headbuf, -1, 'Keyword', 0, -1)
+  end)
 end
 
 
@@ -158,23 +158,23 @@ local function location_callback(_, method, result)
 end
 
 function M.declaration()
-	local params = protocol.make_text_document_position_params()
-	request('textDocument/declaration', params, location_callback)
+  local params = protocol.make_text_document_position_params()
+  request('textDocument/declaration', params, location_callback)
 end
 
 function M.definition()
-	local params = protocol.make_text_document_position_params()
-	request('textDocument/definition', params, location_callback)
+  local params = protocol.make_text_document_position_params()
+  request('textDocument/definition', params, location_callback)
 end
 
 function M.type_definition()
-	local params = protocol.make_text_document_position_params()
-	request('textDocument/typeDefinition', params, location_callback)
+  local params = protocol.make_text_document_position_params()
+  request('textDocument/typeDefinition', params, location_callback)
 end
 
 function M.implementation()
-	local params = protocol.make_text_document_position_params()
-	request('textDocument/implementation', params, location_callback)
+  local params = protocol.make_text_document_position_params()
+  request('textDocument/implementation', params, location_callback)
 end
 
 --- Convert SignatureHelp response to preview contents.
@@ -237,49 +237,50 @@ local function signature_help_to_preview_contents(input)
 end
 
 function M.signature_help()
-	local params = protocol.make_text_document_position_params()
-	focusable_preview('textDocument/signatureHelp', params, function(result)
-		if not (result and result.signatures and result.signatures[1]) then return end
+  local params = protocol.make_text_document_position_params()
+  focusable_preview('textDocument/signatureHelp', params, function(result)
+    if not (result and result.signatures and result.signatures[1]) then return end
 
-		-- TODO show empty popup when signatures is empty?
-		local lines = signature_help_to_preview_contents(result)
-		lines = util.trim_empty_lines(lines)
-		if vim.tbl_isempty(lines) then
-			return { 'No signature available' }
-		end
-		return lines, util.try_trim_markdown_code_blocks(lines)
-	end)
+    -- TODO show empty popup when signatures is empty?
+    local lines = signature_help_to_preview_contents(result)
+    lines = util.trim_empty_lines(lines)
+    if vim.tbl_isempty(lines) then
+      return { 'No signature available' }
+    end
+    return lines, util.try_trim_markdown_code_blocks(lines)
+  end)
 end
 
 -- TODO(ashkan) ?
 function M.completion(context)
-	local params = protocol.make_text_document_position_params()
-	params.context = context
-	return request('textDocument/completion', params, function(_, _, result)
-		if vim.tbl_isempty(result or {}) then return end
-		local row, col = unpack(api.nvim_win_get_cursor(0))
-		local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
-		local line_to_cursor = line:sub(col+1)
+  local params = protocol.make_text_document_position_params()
+  params.context = context
+  return request('textDocument/completion', params, function(_, _, result)
+    if vim.tbl_isempty(result or {}) then return end
+    local row, col = unpack(api.nvim_win_get_cursor(0))
+    local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
+    local line_to_cursor = line:sub(col+1)
 
-		local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
-		vim.fn.complete(col, matches)
-	end)
+    local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
+    vim.fn.complete(col, matches)
+  end)
 end
 
 function M.range_formatting()
 end
 
 function M.rename(new_name)
-	-- TODO(ashkan) use prepareRename
-	-- * result: [`Range`](#range) \| `{ range: Range, placeholder: string }` \| `null` describing the range of the string to rename and optionally a placeholder text of the string content to be renamed. If `null` is returned then it is deemed that a 'textDocument/rename' request is not valid at the given position.
-	local params = protocol.make_text_document_position_params()
-	new_name = new_name or npcall(vfn.input, "New Name: ")
-	if not (new_name and #new_name > 0) then return end
-	params.newName = new_name
-	request('textDocument/rename', params, function(_, _, result)
-		if not result then return end
-		util.workspace_apply_workspace_edit(result)
-	end)
+  -- TODO(ashkan) use prepareRename
+  -- * result: [`Range`](#range) \| `{ range: Range, placeholder: string }` \| `null` describing the range of the string to rename and optionally a placeholder text of the string content to be renamed. If `null` is returned then it is deemed that a 'textDocument/rename' request is not valid at the given position.
+  local params = protocol.make_text_document_position_params()
+  new_name = new_name or npcall(vfn.input, "New Name: ")
+  if not (new_name and #new_name > 0) then return end
+  params.newName = new_name
+  request('textDocument/rename', params, function(_, _, result)
+    if not result then return end
+    util.workspace_apply_workspace_edit(result)
+  end)
 end
 
 return M
+-- vim:sw=2 ts=2 et
-- 
cgit 


From 93beae4f31d42dc70c874020011220444d7f979c Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:35:11 -0800
Subject: Fix rename support.

---
 runtime/lua/vim/lsp/buf.lua  |  1 +
 runtime/lua/vim/lsp/util.lua | 29 +++++++++++------------------
 2 files changed, 12 insertions(+), 18 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 8b21370800..01174a1e48 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -44,6 +44,7 @@ local function request(method, params, callback)
     callback = {callback, 'f'};
   }
   return vim.lsp.buf_request(0, method, params, function(err, _, result, client_id)
+    local _ = log.debug() and log.debug("vim.lsp.buf", method, client_id, err, result)
     if err then error(tostring(err)) end
     return callback(err, method, result, client_id)
   end)
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 13c83fefd6..ab2c02ffcd 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -52,16 +52,12 @@ function M.text_document_apply_text_edit(text_edit, bufnr)
     api.nvim_buf_set_lines(bufnr, start.line, finish.line, false, new_lines)
     return
   end
-  api.nvim_err_writeln('apply_text_edit currently only supports character ranges starting at 0')
-  error('apply_text_edit currently only supports character ranges starting at 0')
-  return
-  --  TODO test and finish this support for character ranges.
---  local lines = api.nvim_buf_get_lines(0, start.line, finish.line + 1, false)
---  local suffix = lines[#lines]:sub(finish.character+2)
---  local prefix = lines[1]:sub(start.character+2)
---  new_lines[#new_lines] = new_lines[#new_lines]..suffix
---  new_lines[1] = prefix..new_lines[1]
---  api.nvim_buf_set_lines(0, start.line, finish.line, false, new_lines)
+ local lines = api.nvim_buf_get_lines(bufnr, start.line, finish.line + 1, false)
+ local suffix = lines[#lines]:sub(finish.character+1)
+ local prefix = lines[1]:sub(1, start.character)
+ new_lines[#new_lines] = new_lines[#new_lines]..suffix
+ new_lines[1] = prefix..new_lines[1]
+ api.nvim_buf_set_lines(bufnr, start.line, finish.line + 1, false, new_lines)
 end
 
 -- textDocument/completion response returns one of CompletionItem[], CompletionList or null.
@@ -158,18 +154,15 @@ function M.workspace_apply_workspace_edit(workspace_edit)
     return
   end
 
-  if workspace_edit.changes == nil or #workspace_edit.changes == 0 then
+  local all_changes = workspace_edit.changes
+  if not (all_changes and not vim.tbl_isempty(all_changes)) then
     return
   end
 
-  for uri, changes in pairs(workspace_edit.changes) do
-    local fname = vim.uri_to_fname(uri)
-    -- TODO improve this approach. Try to edit open buffers without switching.
-    -- Not sure how to handle files which aren't open. This is deprecated
-    -- anyway, so I guess it could be left as is.
-    api.nvim_command('edit '..fname)
+  for uri, changes in pairs(all_changes) do
+    local bufnr = vim.uri_to_bufnr(uri)
     for _, change in ipairs(changes) do
-      M.text_document_apply_text_edit(change)
+      M.text_document_apply_text_edit(change, bufnr)
     end
   end
 end
-- 
cgit 


From 4c7ef3754a7679a7f095fa9e739a665ead4c71b4 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:37:23 -0800
Subject: Satisfy lualint.

---
 runtime/lua/vim/lsp.lua     |  2 +-
 runtime/lua/vim/lsp/buf.lua | 10 +---------
 2 files changed, 2 insertions(+), 10 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 1b9d788c43..b2dc1315dd 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -903,7 +903,7 @@ end
 -- Print some debug information about all LSP related things.
 -- The output of this function should not be relied upon and may change.
 function lsp.print_debug_info()
-  print(vim.inspect({ clients = active_clients, filetype_configs = all_filetype_configs }))
+  print(vim.inspect({ clients = active_clients }))
 end
 
 -- Log level dictionary with reverse lookup as well.
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 01174a1e48..1c2e60f1ca 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -7,14 +7,6 @@ local log = require 'vim.lsp.log'
 
 local M = {}
 
-local function resolve_bufnr(bufnr)
-  validate { bufnr = { bufnr, 'n', true } }
-  if bufnr == nil or bufnr == 0 then
-    return api.nvim_get_current_buf()
-  end
-  return bufnr
-end
-
 local function ok_or_nil(status, ...)
   if not status then return end
   return ...
@@ -198,7 +190,7 @@ local function signature_help_to_preview_contents(input)
   if not signature then
     return
   end
-  vim.list_extend(contents, split_lines(signature.label))
+  vim.list_extend(contents, vim.split(signature.label, '\n', true))
   if signature.documentation then
     util.convert_input_to_markdown_lines(signature.documentation, contents)
   end
-- 
cgit 


From 9b7f95671559a9189569dcb93778e54eaa87f255 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 16:39:45 -0800
Subject: Use err_message in default_callbacks

---
 runtime/lua/vim/lsp/default_callbacks.lua | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
index 63e62075b4..67c33a1667 100644
--- a/runtime/lua/vim/lsp/default_callbacks.lua
+++ b/runtime/lua/vim/lsp/default_callbacks.lua
@@ -20,18 +20,23 @@ M['textDocument/publishDiagnostics'] = function(_, _, result)
   -- util.buf_loclist(bufnr, result.diagnostics)
 end
 
+local function err_message(...)
+  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
+  api.nvim_command("redraw")
+end
+
 local function log_message(_, _, result, client_id)
   local message_type = result.type
   local message = result.message
   local client = vim.lsp.get_client_by_id(client_id)
   local client_name = client and client.name or string.format("id=%d", client_id)
   if not client then
-    api.nvim_err_writeln(string.format("LSP[%s] client has shut down after sending the message", client_name))
+    err_message("LSP[", client_name, "] client has shut down after sending the message")
   end
   if message_type == protocol.MessageType.Error then
     -- Might want to not use err_writeln,
     -- but displaying a message with red highlights or something
-    api.nvim_err_writeln(string.format("LSP[%s] %s", client_name, message))
+    err_message("LSP[", client_name, "] ", message)
   else
     local message_type_name = protocol.MessageType[message_type]
     api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
-- 
cgit 


From b984f613c1e8dadbe59bf0d7093a6ed12af61b37 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 17:09:21 -0800
Subject: Extend list_extend to take start/finish.

---
 runtime/lua/vim/lsp/default_callbacks.lua | 14 ++++++--------
 runtime/lua/vim/lsp/util.lua              |  7 +------
 runtime/lua/vim/shared.lua                | 31 +++++++++++++++++++------------
 3 files changed, 26 insertions(+), 26 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
index 67c33a1667..5e8552307b 100644
--- a/runtime/lua/vim/lsp/default_callbacks.lua
+++ b/runtime/lua/vim/lsp/default_callbacks.lua
@@ -5,12 +5,17 @@ local api = vim.api
 
 local M = {}
 
+local function err_message(...)
+  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
+  api.nvim_command("redraw")
+end
+
 M['textDocument/publishDiagnostics'] = function(_, _, result)
   if not result then return end
   local uri = result.uri
   local bufnr = vim.uri_to_bufnr(uri)
   if not bufnr then
-    api.nvim_err_writeln(string.format("LSP.publishDiagnostics: Couldn't find buffer for %s", uri))
+    err_message("LSP.publishDiagnostics: Couldn't find buffer for ", uri)
     return
   end
   util.buf_clear_diagnostics(bufnr)
@@ -20,11 +25,6 @@ M['textDocument/publishDiagnostics'] = function(_, _, result)
   -- util.buf_loclist(bufnr, result.diagnostics)
 end
 
-local function err_message(...)
-  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
-  api.nvim_command("redraw")
-end
-
 local function log_message(_, _, result, client_id)
   local message_type = result.type
   local message = result.message
@@ -34,8 +34,6 @@ local function log_message(_, _, result, client_id)
     err_message("LSP[", client_name, "] client has shut down after sending the message")
   end
   if message_type == protocol.MessageType.Error then
-    -- Might want to not use err_writeln,
-    -- but displaying a message with red highlights or something
     err_message("LSP[", client_name, "] ", message)
   else
     local message_type_name = protocol.MessageType[message_type]
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index ab2c02ffcd..3a2142a478 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -546,7 +546,6 @@ end
 
 -- Remove empty lines from the beginning and end.
 function M.trim_empty_lines(lines)
-  local result = {}
   local start = 1
   for i = 1, #lines do
     if #lines[i] > 0 then
@@ -561,11 +560,7 @@ function M.trim_empty_lines(lines)
       break
     end
   end
-  -- TODO(ashkan) use tbl_slice.
-  for i = start, finish do
-    table.insert(result, lines[i])
-  end
-  return result
+  return vim.list_extend({}, lines, start, finish)
 end
 
 -- Accepts markdown lines and tries to reduce it to a filetype if it is
diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index ff89acc524..25287ed1aa 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -226,18 +226,25 @@ function vim.tbl_add_reverse_lookup(o)
   return o
 end
 
---- Extends a list-like table with the values of another list-like table.
----
---NOTE: This *mutates* dst!
---@see |extend()|
----
---@param dst The list which will be modified and appended to.
---@param src The list from which values will be inserted.
-function vim.list_extend(dst, src)
-  assert(type(dst) == 'table', "dst must be a table")
-  assert(type(src) == 'table', "src must be a table")
-  for _, v in ipairs(src) do
-    table.insert(dst, v)
+-- Extends a list-like table with the values of another list-like table.
+--
+-- NOTE: This *mutates* dst!
+-- @see |extend()|
+--
+-- @param dst list which will be modified and appended to.
+-- @param src list from which values will be inserted.
+-- @param start Start index on src. defaults to 1
+-- @param finish Final index on src. defaults to #src
+-- @returns dst
+function vim.list_extend(dst, src, start, finish)
+  vim.validate {
+    dst = {dst, 't'};
+    src = {src, 't'};
+    start = {start, 'n', true};
+    finish = {finish, 'n', true};
+  }
+  for i = start or 1, finish or #src do
+    table.insert(dst, src[i])
   end
   return dst
 end
-- 
cgit 


From 6fc409d5939500b038ba281ac1929fd053f35310 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 20:51:44 -0800
Subject: Add full text_edit implementation.

- Implements textDocument/formatting, textDocument/rangeFormatting,
workspace/applyEdit.
TODO:
- still has edge cases around replacement probably. Only tested with
inserts on the same position.
---
 runtime/lua/vim/lsp/buf.lua               | 122 ++++++++++++++++++++++++++-
 runtime/lua/vim/lsp/default_callbacks.lua |   9 ++
 runtime/lua/vim/lsp/util.lua              | 134 ++++++++++++++++++++++--------
 3 files changed, 228 insertions(+), 37 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 1c2e60f1ca..ea88207b5b 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -259,7 +259,127 @@ function M.completion(context)
   end)
 end
 
-function M.range_formatting()
+local function apply_edit_to_lines(lines, start_pos, end_pos, new_lines)
+  -- 0-indexing to 1-indexing makes things look a bit worse.
+  local i_0 = start_pos[1] + 1
+  local i_n = end_pos[1] + 1
+  local n = i_n - i_0 + 1
+  if not lines[i_0] or not lines[i_n] then
+    error(vim.inspect{#lines, i_0, i_n, n, start_pos, end_pos, new_lines})
+  end
+  local prefix = ""
+  local suffix = lines[i_n]:sub(end_pos[2]+1)
+  lines[i_n] = lines[i_n]:sub(1, end_pos[2]+1)
+  if start_pos[2] > 0 then
+    prefix = lines[i_0]:sub(1, start_pos[2])
+    -- lines[i_0] = lines[i_0]:sub(start.character+1)
+  end
+  -- TODO(ashkan) figure out how to avoid copy here. likely by changing algo.
+  new_lines = vim.list_extend({}, new_lines)
+  if #suffix > 0 then
+    new_lines[#new_lines] = new_lines[#new_lines]..suffix
+  end
+  if #prefix > 0 then
+    new_lines[1] = prefix..new_lines[1]
+  end
+  if #new_lines >= n then
+    for i = 1, n do
+      lines[i + i_0 - 1] = new_lines[i]
+    end
+    for i = n+1,#new_lines do
+      table.insert(lines, i_n + 1, new_lines[i])
+    end
+  else
+    for i = 1, #new_lines do
+      lines[i + i_0 - 1] = new_lines[i]
+    end
+    for _ = #new_lines+1, n do
+      table.remove(lines, i_0 + #new_lines + 1)
+    end
+  end
+end
+
+local function apply_text_edits(text_edits, bufnr)
+  if not next(text_edits) then return end
+  -- nvim.print("Start", #text_edits)
+  local start_line, finish_line = math.huge, -1
+  local cleaned = {}
+  for _, e in ipairs(text_edits) do
+    start_line = math.min(e.range.start.line, start_line)
+    finish_line = math.max(e.range["end"].line, finish_line)
+    table.insert(cleaned, {
+      A = {e.range.start.line; e.range.start.character};
+      B = {e.range["end"].line; e.range["end"].character};
+      lines = vim.split(e.newText, '\n', true);
+    })
+  end
+  local lines = api.nvim_buf_get_lines(bufnr, start_line, finish_line + 1, false)
+  for i, e in ipairs(cleaned) do
+    -- nvim.print(i, "e", e.A, e.B, #e.lines[#e.lines], e.lines)
+    local y = 0
+    local x = 0
+    -- TODO(ashkan) this could be done in O(n) with dynamic programming
+    for j = 1, i-1 do
+      local o = cleaned[j]
+      -- nvim.print(i, "o", o.A, o.B, x, y, #o.lines[#o.lines], o.lines)
+      if o.A[1] <= e.A[1] and o.A[2] <= e.A[2] then
+        y = y - (o.B[1] - o.A[1] + 1) + #o.lines
+        -- Same line
+        if #o.lines > 1 then
+          x = -e.A[2] + #o.lines[#o.lines]
+        else
+          if o.A[1] == e.A[1] then
+            -- Try to account for insertions.
+            -- TODO how to account for deletions?
+            x = x - (o.B[2] - o.A[2]) + #o.lines[#o.lines]
+          end
+        end
+      end
+    end
+    local A = {e.A[1] + y - start_line, e.A[2] + x}
+    local B = {e.B[1] + y - start_line, e.B[2] + x}
+    -- if x ~= 0 or y ~= 0 then
+    --   nvim.print(i, "_", e.A, e.B, y, x, A, B, e.lines)
+    -- end
+    apply_edit_to_lines(lines, A, B, e.lines)
+  end
+  api.nvim_buf_set_lines(bufnr, start_line, finish_line + 1, false, lines)
+end
+
+function M.formatting(options)
+  validate { options = {options, 't', true} }
+  local params = {
+    textDocument = { uri = vim.uri_from_bufnr(0) };
+    options = options or {};
+  }
+  params.options[vim.type_idx] = vim.types.dictionary
+  return request('textDocument/formatting', params, function(_, _, result)
+    if not result then return end
+    apply_text_edits(result)
+  end)
+end
+
+function M.range_formatting(options, start_pos, end_pos)
+  validate {
+    options = {options, 't', true};
+    start_pos = {start_pos, 't', true};
+    end_pos = {end_pos, 't', true};
+  }
+  start_pos = start_pos or vim.api.nvim_buf_get_mark(0, '<')
+  end_pos = end_pos or vim.api.nvim_buf_get_mark(0, '>')
+  local params = {
+    textDocument = { uri = vim.uri_from_bufnr(0) };
+    range = {
+      start = { line = start_pos[1]; character = start_pos[2]; };
+      ["end"] = { line = end_pos[1]; character = end_pos[2]; };
+    };
+    options = options or {};
+  }
+  params.options[vim.type_idx] = vim.types.dictionary
+  return request('textDocument/rangeFormatting', params, function(_, _, result)
+    if not result then return end
+    apply_text_edits(result)
+  end)
 end
 
 function M.rename(new_name)
diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
index 5e8552307b..d58280e0f2 100644
--- a/runtime/lua/vim/lsp/default_callbacks.lua
+++ b/runtime/lua/vim/lsp/default_callbacks.lua
@@ -10,6 +10,15 @@ local function err_message(...)
   api.nvim_command("redraw")
 end
 
+M['workspace/applyEdit'] = function(_, _, workspace_edit)
+  if not workspace_edit then return end
+  -- TODO(ashkan) Do something more with label?
+  if workspace_edit.label then
+    print("Workspace edit", workspace_edit.label)
+  end
+  util.apply_workspace_edit(workspace_edit.edit)
+end
+
 M['textDocument/publishDiagnostics'] = function(_, _, result)
   if not result then return end
   local uri = result.uri
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 3a2142a478..004fb81cba 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -33,6 +33,93 @@ local function resolve_bufnr(bufnr)
   return bufnr
 end
 
+function M.apply_edit_to_lines(lines, start_pos, end_pos, new_lines)
+  -- 0-indexing to 1-indexing makes things look a bit worse.
+  local i_0 = start_pos[1] + 1
+  local i_n = end_pos[1] + 1
+  local n = i_n - i_0 + 1
+  if not lines[i_0] or not lines[i_n] then
+    error(vim.inspect{#lines, i_0, i_n, n, start_pos, end_pos, new_lines})
+  end
+  local prefix = ""
+  local suffix = lines[i_n]:sub(end_pos[2]+1)
+  lines[i_n] = lines[i_n]:sub(1, end_pos[2]+1)
+  if start_pos[2] > 0 then
+    prefix = lines[i_0]:sub(1, start_pos[2])
+    -- lines[i_0] = lines[i_0]:sub(start.character+1)
+  end
+  -- TODO(ashkan) figure out how to avoid copy here. likely by changing algo.
+  new_lines = vim.list_extend({}, new_lines)
+  if #suffix > 0 then
+    new_lines[#new_lines] = new_lines[#new_lines]..suffix
+  end
+  if #prefix > 0 then
+    new_lines[1] = prefix..new_lines[1]
+  end
+  if #new_lines >= n then
+    for i = 1, n do
+      lines[i + i_0 - 1] = new_lines[i]
+    end
+    for i = n+1,#new_lines do
+      table.insert(lines, i_n + 1, new_lines[i])
+    end
+  else
+    for i = 1, #new_lines do
+      lines[i + i_0 - 1] = new_lines[i]
+    end
+    for _ = #new_lines+1, n do
+      table.remove(lines, i_0 + #new_lines + 1)
+    end
+  end
+end
+
+function M.apply_text_edits(text_edits, bufnr)
+  if not next(text_edits) then return end
+  -- nvim.print("Start", #text_edits)
+  local start_line, finish_line = math.huge, -1
+  local cleaned = {}
+  for _, e in ipairs(text_edits) do
+    start_line = math.min(e.range.start.line, start_line)
+    finish_line = math.max(e.range["end"].line, finish_line)
+    table.insert(cleaned, {
+      A = {e.range.start.line; e.range.start.character};
+      B = {e.range["end"].line; e.range["end"].character};
+      lines = vim.split(e.newText, '\n', true);
+    })
+  end
+  local lines = api.nvim_buf_get_lines(bufnr, start_line, finish_line + 1, false)
+  for i, e in ipairs(cleaned) do
+    -- nvim.print(i, "e", e.A, e.B, #e.lines[#e.lines], e.lines)
+    local y = 0
+    local x = 0
+    -- TODO(ashkan) this could be done in O(n) with dynamic programming
+    for j = 1, i-1 do
+      local o = cleaned[j]
+      -- nvim.print(i, "o", o.A, o.B, x, y, #o.lines[#o.lines], o.lines)
+      if o.A[1] <= e.A[1] and o.A[2] <= e.A[2] then
+        y = y - (o.B[1] - o.A[1] + 1) + #o.lines
+        -- Same line
+        if #o.lines > 1 then
+          x = -e.A[2] + #o.lines[#o.lines]
+        else
+          if o.A[1] == e.A[1] then
+            -- Try to account for insertions.
+            -- TODO how to account for deletions?
+            x = x - (o.B[2] - o.A[2]) + #o.lines[#o.lines]
+          end
+        end
+      end
+    end
+    local A = {e.A[1] + y - start_line, e.A[2] + x}
+    local B = {e.B[1] + y - start_line, e.B[2] + x}
+    -- if x ~= 0 or y ~= 0 then
+    --   nvim.print(i, "_", e.A, e.B, y, x, A, B, e.lines)
+    -- end
+    M.apply_edit_to_lines(lines, A, B, e.lines)
+  end
+  api.nvim_buf_set_lines(bufnr, start_line, finish_line + 1, false, lines)
+end
+
 -- local valid_windows_path_characters = "[^<>:\"/\\|?*]"
 -- local valid_unix_path_characters = "[^/]"
 -- https://github.com/davidm/lua-glob-pattern
@@ -40,26 +127,6 @@ end
 -- function M.glob_to_regex(glob)
 -- end
 
---- Apply the TextEdit response.
--- @params TextEdit [table] see https://microsoft.github.io/language-server-protocol/specification
-function M.text_document_apply_text_edit(text_edit, bufnr)
-  bufnr = resolve_bufnr(bufnr)
-  local range = text_edit.range
-  local start = range.start
-  local finish = range['end']
-  local new_lines = split_lines(text_edit.newText)
-  if start.character == 0 and finish.character == 0 then
-    api.nvim_buf_set_lines(bufnr, start.line, finish.line, false, new_lines)
-    return
-  end
- local lines = api.nvim_buf_get_lines(bufnr, start.line, finish.line + 1, false)
- local suffix = lines[#lines]:sub(finish.character+1)
- local prefix = lines[1]:sub(1, start.character)
- new_lines[#new_lines] = new_lines[#new_lines]..suffix
- new_lines[1] = prefix..new_lines[1]
- api.nvim_buf_set_lines(bufnr, start.line, finish.line + 1, false, new_lines)
-end
-
 -- textDocument/completion response returns one of CompletionItem[], CompletionList or null.
 -- https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
 function M.extract_completion_items(result)
@@ -74,18 +141,15 @@ end
 
 --- Apply the TextDocumentEdit response.
 -- @params TextDocumentEdit [table] see https://microsoft.github.io/language-server-protocol/specification
-function M.text_document_apply_text_document_edit(text_document_edit, bufnr)
-  -- local text_document = text_document_edit.textDocument
-  -- TODO use text_document_version?
-  -- local text_document_version = text_document.version
-
-  -- TODO technically, you could do this without doing multiple buf_get/set
-  -- by getting the full region (smallest line and largest line) and doing
-  -- the edits on the buffer, and then applying the buffer at the end.
-  -- I'm not sure if that's better.
-  for _, text_edit in ipairs(text_document_edit.edits) do
-    M.text_document_apply_text_edit(text_edit, bufnr)
+function M.apply_text_document_edit(text_document_edit)
+  local text_document = text_document_edit.textDocument
+  local bufnr = vim.uri_to_bufnr(text_document.uri)
+  -- TODO(ashkan) check this is correct.
+  if api.nvim_buf_get_changedtick(bufnr) > text_document.version then
+    print("Buffer ", text_document.uri, " newer than edits.")
+    return
   end
+  M.apply_text_edits(text_document_edit.edits, bufnr)
 end
 
 function M.get_current_line_to_cursor()
@@ -141,14 +205,14 @@ function M.text_document_completion_list_to_complete_items(result, line_prefix)
 end
 
 -- @params WorkspaceEdit [table] see https://microsoft.github.io/language-server-protocol/specification
-function M.workspace_apply_workspace_edit(workspace_edit)
+function M.apply_workspace_edit(workspace_edit)
   if workspace_edit.documentChanges then
     for _, change in ipairs(workspace_edit.documentChanges) do
       if change.kind then
         -- TODO(ashkan) handle CreateFile/RenameFile/DeleteFile
         error(string.format("Unsupported change: %q", vim.inspect(change)))
       else
-        M.text_document_apply_text_document_edit(change)
+        M.apply_text_document_edit(change)
       end
     end
     return
@@ -161,9 +225,7 @@ function M.workspace_apply_workspace_edit(workspace_edit)
 
   for uri, changes in pairs(all_changes) do
     local bufnr = vim.uri_to_bufnr(uri)
-    for _, change in ipairs(changes) do
-      M.text_document_apply_text_edit(change, bufnr)
-    end
+    M.apply_text_edits(changes, bufnr)
   end
 end
 
-- 
cgit 


From 6d9f48ddcf3a4d0fbed0674ce180bcfb9340bb22 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 20:57:21 -0800
Subject: Fix reference in rename.

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index ea88207b5b..68af34dac6 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -391,7 +391,7 @@ function M.rename(new_name)
   params.newName = new_name
   request('textDocument/rename', params, function(_, _, result)
     if not result then return end
-    util.workspace_apply_workspace_edit(result)
+    util.apply_workspace_edit(result)
   end)
 end
 
-- 
cgit 


From 7bf766ad0903574b6202af0d2e11d306d656b491 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 20:59:12 -0800
Subject: Use the apply_text_edits from util.

---
 runtime/lua/vim/lsp/buf.lua | 91 +--------------------------------------------
 1 file changed, 2 insertions(+), 89 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 68af34dac6..260bca281f 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -259,93 +259,6 @@ function M.completion(context)
   end)
 end
 
-local function apply_edit_to_lines(lines, start_pos, end_pos, new_lines)
-  -- 0-indexing to 1-indexing makes things look a bit worse.
-  local i_0 = start_pos[1] + 1
-  local i_n = end_pos[1] + 1
-  local n = i_n - i_0 + 1
-  if not lines[i_0] or not lines[i_n] then
-    error(vim.inspect{#lines, i_0, i_n, n, start_pos, end_pos, new_lines})
-  end
-  local prefix = ""
-  local suffix = lines[i_n]:sub(end_pos[2]+1)
-  lines[i_n] = lines[i_n]:sub(1, end_pos[2]+1)
-  if start_pos[2] > 0 then
-    prefix = lines[i_0]:sub(1, start_pos[2])
-    -- lines[i_0] = lines[i_0]:sub(start.character+1)
-  end
-  -- TODO(ashkan) figure out how to avoid copy here. likely by changing algo.
-  new_lines = vim.list_extend({}, new_lines)
-  if #suffix > 0 then
-    new_lines[#new_lines] = new_lines[#new_lines]..suffix
-  end
-  if #prefix > 0 then
-    new_lines[1] = prefix..new_lines[1]
-  end
-  if #new_lines >= n then
-    for i = 1, n do
-      lines[i + i_0 - 1] = new_lines[i]
-    end
-    for i = n+1,#new_lines do
-      table.insert(lines, i_n + 1, new_lines[i])
-    end
-  else
-    for i = 1, #new_lines do
-      lines[i + i_0 - 1] = new_lines[i]
-    end
-    for _ = #new_lines+1, n do
-      table.remove(lines, i_0 + #new_lines + 1)
-    end
-  end
-end
-
-local function apply_text_edits(text_edits, bufnr)
-  if not next(text_edits) then return end
-  -- nvim.print("Start", #text_edits)
-  local start_line, finish_line = math.huge, -1
-  local cleaned = {}
-  for _, e in ipairs(text_edits) do
-    start_line = math.min(e.range.start.line, start_line)
-    finish_line = math.max(e.range["end"].line, finish_line)
-    table.insert(cleaned, {
-      A = {e.range.start.line; e.range.start.character};
-      B = {e.range["end"].line; e.range["end"].character};
-      lines = vim.split(e.newText, '\n', true);
-    })
-  end
-  local lines = api.nvim_buf_get_lines(bufnr, start_line, finish_line + 1, false)
-  for i, e in ipairs(cleaned) do
-    -- nvim.print(i, "e", e.A, e.B, #e.lines[#e.lines], e.lines)
-    local y = 0
-    local x = 0
-    -- TODO(ashkan) this could be done in O(n) with dynamic programming
-    for j = 1, i-1 do
-      local o = cleaned[j]
-      -- nvim.print(i, "o", o.A, o.B, x, y, #o.lines[#o.lines], o.lines)
-      if o.A[1] <= e.A[1] and o.A[2] <= e.A[2] then
-        y = y - (o.B[1] - o.A[1] + 1) + #o.lines
-        -- Same line
-        if #o.lines > 1 then
-          x = -e.A[2] + #o.lines[#o.lines]
-        else
-          if o.A[1] == e.A[1] then
-            -- Try to account for insertions.
-            -- TODO how to account for deletions?
-            x = x - (o.B[2] - o.A[2]) + #o.lines[#o.lines]
-          end
-        end
-      end
-    end
-    local A = {e.A[1] + y - start_line, e.A[2] + x}
-    local B = {e.B[1] + y - start_line, e.B[2] + x}
-    -- if x ~= 0 or y ~= 0 then
-    --   nvim.print(i, "_", e.A, e.B, y, x, A, B, e.lines)
-    -- end
-    apply_edit_to_lines(lines, A, B, e.lines)
-  end
-  api.nvim_buf_set_lines(bufnr, start_line, finish_line + 1, false, lines)
-end
-
 function M.formatting(options)
   validate { options = {options, 't', true} }
   local params = {
@@ -355,7 +268,7 @@ function M.formatting(options)
   params.options[vim.type_idx] = vim.types.dictionary
   return request('textDocument/formatting', params, function(_, _, result)
     if not result then return end
-    apply_text_edits(result)
+    util.apply_text_edits(result)
   end)
 end
 
@@ -378,7 +291,7 @@ function M.range_formatting(options, start_pos, end_pos)
   params.options[vim.type_idx] = vim.types.dictionary
   return request('textDocument/rangeFormatting', params, function(_, _, result)
     if not result then return end
-    apply_text_edits(result)
+    util.apply_text_edits(result)
   end)
 end
 
-- 
cgit 


From b7170f2d722cee24a62eb74ac836d6192e5475dc Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Wed, 20 Nov 2019 20:59:52 -0800
Subject: Remove resolve_bufnr/lualint

---
 runtime/lua/vim/lsp/util.lua | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 004fb81cba..dcf2c17df4 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -26,13 +26,6 @@ local function remove_prefix(prefix, word)
   return word:sub(prefix_length + 1)
 end
 
-local function resolve_bufnr(bufnr)
-  if bufnr == nil or bufnr == 0 then
-    return api.nvim_get_current_buf()
-  end
-  return bufnr
-end
-
 function M.apply_edit_to_lines(lines, start_pos, end_pos, new_lines)
   -- 0-indexing to 1-indexing makes things look a bit worse.
   local i_0 = start_pos[1] + 1
-- 
cgit 


From 76e0a8bd935b27270f8f6a594c3025bc494f4422 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Thu, 21 Nov 2019 10:29:54 +0100
Subject: lsp: transmit "\n" after last line when 'eol' is set

Otherwise some servers like clangd will emit spurious
"no newline at end of file" warnings.
---
 runtime/lua/vim/lsp.lua | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 9dbe03dace..0c1a145c04 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -23,7 +23,6 @@ local lsp = {
   -- format_rpc_error = lsp_rpc.format_rpc_error;
 }
 
--- TODO consider whether 'eol' or 'fixeol' should change the nvim_buf_get_lines that send.
 -- TODO improve handling of scratch buffers with LSP attached.
 
 local function resolve_bufnr(bufnr)
@@ -175,6 +174,14 @@ local function validate_client_config(config)
   }
 end
 
+local function buf_get_full_text(bufnr)
+  local text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, true), '\n')
+  if nvim_buf_get_option(bufnr, 'eol') then
+    text = text .. '\n'
+  end
+  return text
+end
+
 local function text_document_did_open_handler(bufnr, client)
   if not client.resolved_capabilities.text_document_open_close then
     return
@@ -188,7 +195,7 @@ local function text_document_did_open_handler(bufnr, client)
       uri = vim.uri_from_bufnr(bufnr);
       -- TODO make sure our filetypes are compatible with languageId names.
       languageId = nvim_buf_get_option(bufnr, 'filetype');
-      text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, false), '\n');
+      text = buf_get_full_text(bufnr);
     }
   }
   client.notify('textDocument/didOpen', params)
@@ -551,7 +558,7 @@ do
     end)
     local full_changes = once(function()
       return {
-        text = table.concat(nvim_buf_get_lines(bufnr, 0, -1, false), "\n");
+        text = buf_get_full_text(bufnr);
       };
     end)
     local uri = vim.uri_from_bufnr(bufnr)
-- 
cgit 


From bcae04f6c62b23104e85bb08c54a16d0cdc33852 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 15:19:06 -0800
Subject: Updates

- Use correct implementation of text_edits.
- Send indent options to rangeFormatting and formatting.
- Remove references to vim bindings and filetype from lsp.txt
- Add more examples to docs.
- Add before_init to allow changing initialize_params.
---
 runtime/lua/vim/lsp.lua      |  13 ++++-
 runtime/lua/vim/lsp/buf.lua  |  14 ++++--
 runtime/lua/vim/lsp/util.lua | 110 ++++++++++++++++++++-----------------------
 3 files changed, 73 insertions(+), 64 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 5a0b320f4c..790f8f8a9d 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -160,13 +160,13 @@ local function validate_client_config(config)
     root_dir        = { config.root_dir, is_dir, "directory" };
     callbacks       = { config.callbacks, "t", true };
     capabilities    = { config.capabilities, "t", true };
-    -- cmd             = { config.cmd, "s", false };
     cmd_cwd         = { config.cmd_cwd, optional_validator(is_dir), "directory" };
     cmd_env         = { config.cmd_env, "f", true };
     name            = { config.name, 's', true };
     on_error        = { config.on_error, "f", true };
     on_exit         = { config.on_exit, "f", true };
     on_init         = { config.on_init, "f", true };
+    before_init     = { config.before_init, "f", true };
     offset_encoding = { config.offset_encoding, "s", true };
   }
   local cmd, cmd_args = validate_command(config.cmd)
@@ -267,6 +267,12 @@ end
 -- possible errors. `vim.lsp.client_errors[code]` can be used to retrieve a
 -- human understandable string.
 --
+-- before_init(initialize_params, config): A function which is called *before*
+-- the request `initialize` is completed. `initialize_params` contains
+-- the parameters we are sending to the server and `config` is the config that
+-- was passed to `start_client()` for convenience. You can use this to modify
+-- parameters before they are sent.
+--
 -- on_init(client, initialize_result): A function which is called after the
 -- request `initialize` is completed. `initialize_result` contains
 -- `capabilities` and anything else the server may send. For example, `clangd`
@@ -385,7 +391,6 @@ function lsp.start_client(config)
       -- The rootUri of the workspace. Is null if no folder is open. If both
       -- `rootPath` and `rootUri` are set `rootUri` wins.
       rootUri = vim.uri_from_fname(config.root_dir);
---      rootUri = vim.uri_from_fname(vim.fn.expand("%:p:h"));
       -- User provided initialization options.
       initializationOptions = config.init_options;
       -- The capabilities provided by the client (editor or tool)
@@ -409,6 +414,10 @@ function lsp.start_client(config)
       -- }
       workspaceFolders = nil;
     }
+    if config.before_init then
+      -- TODO(ashkan) handle errors here.
+      pcall(config.before_init, initialize_params, config)
+    end
     local _ = log.debug() and log.debug(log_prefix, "initialize_params", initialize_params)
     rpc.request('initialize', initialize_params, function(init_err, result)
       assert(not init_err, tostring(init_err))
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 260bca281f..dbc141a906 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -261,11 +261,14 @@ end
 
 function M.formatting(options)
   validate { options = {options, 't', true} }
+  options = vim.tbl_extend('keep', options or {}, {
+    tabSize = api.nvim_buf_get_option(0, 'tabstop');
+    insertSpaces = api.nvim_buf_get_option(0, 'expandtab');
+  })
   local params = {
     textDocument = { uri = vim.uri_from_bufnr(0) };
-    options = options or {};
+    options = options;
   }
-  params.options[vim.type_idx] = vim.types.dictionary
   return request('textDocument/formatting', params, function(_, _, result)
     if not result then return end
     util.apply_text_edits(result)
@@ -278,6 +281,10 @@ function M.range_formatting(options, start_pos, end_pos)
     start_pos = {start_pos, 't', true};
     end_pos = {end_pos, 't', true};
   }
+  options = vim.tbl_extend('keep', options or {}, {
+    tabSize = api.nvim_buf_get_option(0, 'tabstop');
+    insertSpaces = api.nvim_buf_get_option(0, 'expandtab');
+  })
   start_pos = start_pos or vim.api.nvim_buf_get_mark(0, '<')
   end_pos = end_pos or vim.api.nvim_buf_get_mark(0, '>')
   local params = {
@@ -286,9 +293,8 @@ function M.range_formatting(options, start_pos, end_pos)
       start = { line = start_pos[1]; character = start_pos[2]; };
       ["end"] = { line = end_pos[1]; character = end_pos[2]; };
     };
-    options = options or {};
+    options = options;
   }
-  params.options[vim.type_idx] = vim.types.dictionary
   return request('textDocument/rangeFormatting', params, function(_, _, result)
     if not result then return end
     util.apply_text_edits(result)
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index dcf2c17df4..66430fffc7 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -26,89 +26,83 @@ local function remove_prefix(prefix, word)
   return word:sub(prefix_length + 1)
 end
 
-function M.apply_edit_to_lines(lines, start_pos, end_pos, new_lines)
-  -- 0-indexing to 1-indexing makes things look a bit worse.
-  local i_0 = start_pos[1] + 1
-  local i_n = end_pos[1] + 1
-  local n = i_n - i_0 + 1
-  if not lines[i_0] or not lines[i_n] then
-    error(vim.inspect{#lines, i_0, i_n, n, start_pos, end_pos, new_lines})
+-- TODO(ashkan) @performance this could do less copying.
+function M.set_lines(lines, A, B, new_lines)
+  -- 0-indexing to 1-indexing
+  local i_0 = A[1] + 1
+  local i_n = B[1] + 1
+  if not (i_0 >= 1 and i_0 <= #lines and i_n >= 1 and i_n <= #lines) then
+    error("Invalid range: "..vim.inspect{A = A; B = B; #lines, new_lines})
   end
   local prefix = ""
-  local suffix = lines[i_n]:sub(end_pos[2]+1)
-  lines[i_n] = lines[i_n]:sub(1, end_pos[2]+1)
-  if start_pos[2] > 0 then
-    prefix = lines[i_0]:sub(1, start_pos[2])
-    -- lines[i_0] = lines[i_0]:sub(start.character+1)
-  end
-  -- TODO(ashkan) figure out how to avoid copy here. likely by changing algo.
-  new_lines = vim.list_extend({}, new_lines)
+  local suffix = lines[i_n]:sub(B[2]+1)
+  if A[2] > 0 then
+    prefix = lines[i_0]:sub(1, A[2])
+  end
+  new_lines = list_extend({}, new_lines)
   if #suffix > 0 then
     new_lines[#new_lines] = new_lines[#new_lines]..suffix
   end
   if #prefix > 0 then
     new_lines[1] = prefix..new_lines[1]
   end
-  if #new_lines >= n then
-    for i = 1, n do
-      lines[i + i_0 - 1] = new_lines[i]
-    end
-    for i = n+1,#new_lines do
-      table.insert(lines, i_n + 1, new_lines[i])
-    end
-  else
-    for i = 1, #new_lines do
-      lines[i + i_0 - 1] = new_lines[i]
-    end
-    for _ = #new_lines+1, n do
-      table.remove(lines, i_0 + #new_lines + 1)
+  local result = list_extend({}, lines, 1, i_0 - 1)
+  list_extend(result, new_lines)
+  list_extend(result, lines, i_n + 1)
+  return result
+end
+
+local function sort_by_key(fn)
+  return function(a,b)
+    local ka, kb = fn(a), fn(b)
+    assert(#ka == #kb)
+    for i = 1, #ka do
+      if ka[i] ~= kb[i] then
+        return ka[i] < kb[i]
+      end
     end
+    -- every value must have been equal here, which means it's not less than.
+    return false
   end
 end
+local edit_sort_key = sort_by_key(function(e)
+  return {e.A[1], e.A[2], e.i}
+end)
 
 function M.apply_text_edits(text_edits, bufnr)
   if not next(text_edits) then return end
-  -- nvim.print("Start", #text_edits)
   local start_line, finish_line = math.huge, -1
   local cleaned = {}
-  for _, e in ipairs(text_edits) do
+  for i, e in ipairs(text_edits) do
     start_line = math.min(e.range.start.line, start_line)
     finish_line = math.max(e.range["end"].line, finish_line)
+    -- TODO(ashkan) sanity check ranges for overlap.
     table.insert(cleaned, {
+      i = i;
       A = {e.range.start.line; e.range.start.character};
       B = {e.range["end"].line; e.range["end"].character};
       lines = vim.split(e.newText, '\n', true);
     })
   end
+
+  -- Reverse sort the orders so we can apply them without interfering with
+  -- eachother. Also add i as a sort key to mimic a stable sort.
+  table.sort(cleaned, edit_sort_key)
   local lines = api.nvim_buf_get_lines(bufnr, start_line, finish_line + 1, false)
-  for i, e in ipairs(cleaned) do
-    -- nvim.print(i, "e", e.A, e.B, #e.lines[#e.lines], e.lines)
-    local y = 0
-    local x = 0
-    -- TODO(ashkan) this could be done in O(n) with dynamic programming
-    for j = 1, i-1 do
-      local o = cleaned[j]
-      -- nvim.print(i, "o", o.A, o.B, x, y, #o.lines[#o.lines], o.lines)
-      if o.A[1] <= e.A[1] and o.A[2] <= e.A[2] then
-        y = y - (o.B[1] - o.A[1] + 1) + #o.lines
-        -- Same line
-        if #o.lines > 1 then
-          x = -e.A[2] + #o.lines[#o.lines]
-        else
-          if o.A[1] == e.A[1] then
-            -- Try to account for insertions.
-            -- TODO how to account for deletions?
-            x = x - (o.B[2] - o.A[2]) + #o.lines[#o.lines]
-          end
-        end
-      end
-    end
-    local A = {e.A[1] + y - start_line, e.A[2] + x}
-    local B = {e.B[1] + y - start_line, e.B[2] + x}
-    -- if x ~= 0 or y ~= 0 then
-    --   nvim.print(i, "_", e.A, e.B, y, x, A, B, e.lines)
-    -- end
-    M.apply_edit_to_lines(lines, A, B, e.lines)
+  local fix_eol = api.nvim_buf_get_option(bufnr, 'fixeol')
+  local set_eol = fix_eol and api.nvim_buf_line_count(bufnr) == finish_line + 1
+  if set_eol and #lines[#lines] ~= 0 then
+    table.insert(lines, '')
+  end
+
+  for i = #cleaned, 1, -1 do
+    local e = cleaned[i]
+    local A = {e.A[1] - start_line, e.A[2]}
+    local B = {e.B[1] - start_line, e.B[2]}
+    lines = M.set_lines(lines, A, B, e.lines)
+  end
+  if set_eol and #lines[#lines] == 0 then
+    table.remove(lines)
   end
   api.nvim_buf_set_lines(bufnr, start_line, finish_line + 1, false, lines)
 end
-- 
cgit 


From b27965538dcc3faa8e1c5b3d64a98108c18981ec Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 15:20:32 -0800
Subject: Fix hovers staying on bufhidden

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 66430fffc7..77f2ae6fbc 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -335,7 +335,7 @@ function M.open_floating_preview(contents, filetype, opts)
   end
   api.nvim_buf_set_lines(floating_bufnr, 0, -1, true, contents)
   api.nvim_buf_set_option(floating_bufnr, 'modifiable', false)
-  api.nvim_command("autocmd CursorMoved <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
+  api.nvim_command("autocmd CursorMoved,BufHidden <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
   return floating_bufnr, floating_winnr
 end
 
-- 
cgit 


From da07e71b189a51008a93783b5f7894dc495c277e Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 15:34:28 -0800
Subject: Account for character length in jump position.

---
 runtime/lua/vim/lsp/buf.lua | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index dbc141a906..0b4ac6ca9b 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -134,12 +134,14 @@ local function handle_location(result)
     err_message('[LSP] Could not find a valid location')
     return
   end
-  local result_file = vim.uri_to_fname(result.uri)
-  local bufnr = vfn.bufadd(result_file)
+  local bufnr = vim.uri_to_bufnr(result.uri)
   update_tagstack()
   api.nvim_set_current_buf(bufnr)
-  local start = result.range.start
-  api.nvim_win_set_cursor(0, {start.line + 1, start.character})
+  local row = result.range.start.line
+  local col = result.range.start.character
+  local line = api.nvim_buf_get_lines(0, row, row+1, true)[1]
+  col = #line:sub(1, col)
+  api.nvim_win_set_cursor(0, {row + 1, col})
   return true
 end
 local function location_callback(_, method, result)
-- 
cgit 


From 43d73ee884f97861c44adab4797a8fc185af1436 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 15:41:32 -0800
Subject: Fix position params for encoding.

---
 runtime/lua/vim/lsp/buf.lua      | 18 +++++++++---------
 runtime/lua/vim/lsp/protocol.lua | 13 -------------
 runtime/lua/vim/lsp/util.lua     | 11 +++++++++++
 3 files changed, 20 insertions(+), 22 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 0b4ac6ca9b..ed26e80c3c 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -65,7 +65,7 @@ local function focusable_preview(method, params, fn)
 end
 
 function M.hover()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   focusable_preview('textDocument/hover', params, function(result)
     if not (result and result.contents) then return end
 
@@ -79,7 +79,7 @@ function M.hover()
 end
 
 function M.peek_definition()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   request('textDocument/peekDefinition', params, function(_, _, result, _)
     if not (result and result[1]) then return end
     local loc = result[1]
@@ -153,22 +153,22 @@ local function location_callback(_, method, result)
 end
 
 function M.declaration()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   request('textDocument/declaration', params, location_callback)
 end
 
 function M.definition()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   request('textDocument/definition', params, location_callback)
 end
 
 function M.type_definition()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   request('textDocument/typeDefinition', params, location_callback)
 end
 
 function M.implementation()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   request('textDocument/implementation', params, location_callback)
 end
 
@@ -232,7 +232,7 @@ local function signature_help_to_preview_contents(input)
 end
 
 function M.signature_help()
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   focusable_preview('textDocument/signatureHelp', params, function(result)
     if not (result and result.signatures and result.signatures[1]) then return end
 
@@ -248,7 +248,7 @@ end
 
 -- TODO(ashkan) ?
 function M.completion(context)
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   params.context = context
   return request('textDocument/completion', params, function(_, _, result)
     if vim.tbl_isempty(result or {}) then return end
@@ -306,7 +306,7 @@ end
 function M.rename(new_name)
   -- TODO(ashkan) use prepareRename
   -- * result: [`Range`](#range) \| `{ range: Range, placeholder: string }` \| `null` describing the range of the string to rename and optionally a placeholder text of the string content to be renamed. If `null` is returned then it is deemed that a 'textDocument/rename' request is not valid at the given position.
-  local params = protocol.make_text_document_position_params()
+  local params = util.make_position_params()
   new_name = new_name or npcall(vfn.input, "New Name: ")
   if not (new_name and #new_name > 0) then return end
   params.newName = new_name
diff --git a/runtime/lua/vim/lsp/protocol.lua b/runtime/lua/vim/lsp/protocol.lua
index 1f51e7bef7..ead90cc75a 100644
--- a/runtime/lua/vim/lsp/protocol.lua
+++ b/runtime/lua/vim/lsp/protocol.lua
@@ -680,19 +680,6 @@ function protocol.make_client_capabilities()
   }
 end
 
-function protocol.make_text_document_position_params()
-  local position = vim.api.nvim_win_get_cursor(0)
-  return {
-    textDocument = {
-      uri = vim.uri_from_bufnr()
-    };
-    position = {
-      line = position[1] - 1;
-      character = position[2];
-    }
-  }
-end
-
 --[=[
 export interface DocumentFilter {
   --A language id, like `typescript`.
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 77f2ae6fbc..76681920bd 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -638,6 +638,17 @@ function M.try_trim_markdown_code_blocks(lines)
   return 'markdown'
 end
 
+function M.make_position_params()
+  local row, col = unpack(api.nvim_win_get_cursor(0))
+  row = row - 1
+  local line = api.nvim_buf_get_lines(0, row, row+1, true)[1]
+  col = vim.str_utfindex(line, col)
+  return {
+    textDocument = { uri = vim.uri_from_bufnr(0) };
+    position = { line = row; character = col; }
+  }
+end
+
 
 return M
 -- vim:sw=2 ts=2 et
-- 
cgit 


From c055ca00ce61499e9161b8d2fa48568e833ee5b0 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 15:55:45 -0800
Subject: Remove comments.

---
 runtime/lua/vim/lsp.lua | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 790f8f8a9d..17d6001496 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -98,11 +98,7 @@ local function for_each_buffer_client(bufnr, callback)
     return
   end
   for client_id in pairs(client_ids) do
-    -- This is unlikely to happen. Could only potentially happen in a race
-    -- condition between literally a single statement.
-    -- We could skip this error, but let's error for now.
     local client = active_clients[client_id]
-        -- or error(string.format("Client %d has already shut down.", client_id))
     if client then
       callback(client, client_id)
     end
-- 
cgit 


From a3d67dac5f9de6099890ae4b9fab2b70b2279a29 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 16:23:12 -0800
Subject: Fix encoding translation in other places.

---
 runtime/lua/vim/lsp.lua      |  2 +-
 runtime/lua/vim/lsp/buf.lua  | 22 ++++++++++++++++------
 runtime/lua/vim/lsp/util.lua |  7 +++++++
 3 files changed, 24 insertions(+), 7 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 17d6001496..880d811647 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -862,7 +862,7 @@ function lsp.omnifunc(findstart, base)
       position = {
         -- 0-indexed for both line and character
         line = pos[1] - 1,
-        character = pos[2],
+        character = vim.str_utfindex(line, pos[2]),
       };
       -- The completion context. This is only available if the client specifies
       -- to send this using `ClientCapabilities.textDocument.completion.contextSupport === true`
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index ed26e80c3c..b4e0b9cbfc 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -2,8 +2,8 @@ local validate = vim.validate
 local api = vim.api
 local vfn = vim.fn
 local util = require 'vim.lsp.util'
-local protocol = require 'vim.lsp.protocol'
 local log = require 'vim.lsp.log'
+local list_extend = vim.list_extend
 
 local M = {}
 
@@ -192,7 +192,7 @@ local function signature_help_to_preview_contents(input)
   if not signature then
     return
   end
-  vim.list_extend(contents, vim.split(signature.label, '\n', true))
+  list_extend(contents, vim.split(signature.label, '\n', true))
   if signature.documentation then
     util.convert_input_to_markdown_lines(signature.documentation, contents)
   end
@@ -287,13 +287,23 @@ function M.range_formatting(options, start_pos, end_pos)
     tabSize = api.nvim_buf_get_option(0, 'tabstop');
     insertSpaces = api.nvim_buf_get_option(0, 'expandtab');
   })
-  start_pos = start_pos or vim.api.nvim_buf_get_mark(0, '<')
-  end_pos = end_pos or vim.api.nvim_buf_get_mark(0, '>')
+  local A = list_extend({}, start_pos or api.nvim_buf_get_mark(0, '<'))
+  local B = list_extend({}, end_pos or api.nvim_buf_get_mark(0, '>'))
+  -- convert to 0-index
+  A[1] = A[1] - 1
+  B[1] = B[1] - 1
+  -- account for encoding.
+  if A[2] > 0 then
+    A = {A[1], util.character_offset(0, unpack(A))}
+  end
+  if B[2] > 0 then
+    B = {B[1], util.character_offset(0, unpack(B))}
+  end
   local params = {
     textDocument = { uri = vim.uri_from_bufnr(0) };
     range = {
-      start = { line = start_pos[1]; character = start_pos[2]; };
-      ["end"] = { line = end_pos[1]; character = end_pos[2]; };
+      start = { line = A[1]; character = A[2]; };
+      ["end"] = { line = B[1]; character = B[2]; };
     };
     options = options;
   }
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 76681920bd..570c4df1dd 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -649,6 +649,13 @@ function M.make_position_params()
   }
 end
 
+-- @param buf buffer handle or 0 for current.
+-- @param row 0-indexed line
+-- @param col 0-indexed byte offset in line
+function M.character_offset(buf, row, col)
+  local line = api.nvim_buf_get_lines(buf, row, row+1, true)[1]
+  return vim.str_utfindex(line, col)
+end
 
 return M
 -- vim:sw=2 ts=2 et
-- 
cgit 


From 78991ffbf4357ba1ad477a13991078bb4a0bdc58 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Thu, 21 Nov 2019 23:58:32 -0800
Subject: Improve performance of util.set_lines + bugfix

Also permit character_offset for col past the end of line (useful in
range formatting).
---
 runtime/lua/vim/lsp/util.lua | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 570c4df1dd..94b4223a20 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -11,6 +11,14 @@ end
 
 local list_extend = vim.list_extend
 
+local function ok_or_nil(status, ...)
+  if not status then return end
+  return ...
+end
+local function npcall(fn, ...)
+  return ok_or_nil(pcall(fn, ...))
+end
+
 --- Find the longest shared prefix between prefix and word.
 -- e.g. remove_prefix("123tes", "testing") == "ting"
 local function remove_prefix(prefix, word)
@@ -39,17 +47,22 @@ function M.set_lines(lines, A, B, new_lines)
   if A[2] > 0 then
     prefix = lines[i_0]:sub(1, A[2])
   end
-  new_lines = list_extend({}, new_lines)
+  local n = i_n - i_0 + 1
+  if n ~= #new_lines then
+    for _ = 1, n - #new_lines do table.remove(lines, i_0) end
+    for _ = 1, #new_lines - n do table.insert(lines, i_0, '') end
+  end
+  for i = 1, #new_lines do
+    lines[i - 1 + i_0] = new_lines[i]
+  end
   if #suffix > 0 then
-    new_lines[#new_lines] = new_lines[#new_lines]..suffix
+    local i = i_0 + #new_lines - 1
+    lines[i] = lines[i]..suffix
   end
   if #prefix > 0 then
-    new_lines[1] = prefix..new_lines[1]
+    lines[i_0] = prefix..lines[i_0]
   end
-  local result = list_extend({}, lines, 1, i_0 - 1)
-  list_extend(result, new_lines)
-  list_extend(result, lines, i_n + 1)
-  return result
+  return lines
 end
 
 local function sort_by_key(fn)
@@ -99,7 +112,7 @@ function M.apply_text_edits(text_edits, bufnr)
     local e = cleaned[i]
     local A = {e.A[1] - start_line, e.A[2]}
     local B = {e.B[1] - start_line, e.B[2]}
-    lines = M.set_lines(lines, A, B, e.lines)
+    M.set_lines(lines, A, B, e.lines)
   end
   if set_eol and #lines[#lines] == 0 then
     table.remove(lines)
@@ -638,11 +651,12 @@ function M.try_trim_markdown_code_blocks(lines)
   return 'markdown'
 end
 
+local str_utfindex = vim.str_utfindex
 function M.make_position_params()
   local row, col = unpack(api.nvim_win_get_cursor(0))
   row = row - 1
   local line = api.nvim_buf_get_lines(0, row, row+1, true)[1]
-  col = vim.str_utfindex(line, col)
+  col = str_utfindex(line, col)
   return {
     textDocument = { uri = vim.uri_from_bufnr(0) };
     position = { line = row; character = col; }
@@ -654,7 +668,9 @@ end
 -- @param col 0-indexed byte offset in line
 function M.character_offset(buf, row, col)
   local line = api.nvim_buf_get_lines(buf, row, row+1, true)[1]
-  return vim.str_utfindex(line, col)
+  -- TODO(ashkan) is there a better way to handle col being past line length?
+  -- If the col is past the EOL, use the line length.
+  return npcall(str_utfindex, line, col) or str_utfindex(line)
 end
 
 return M
-- 
cgit 


From 73487f4130581da72c9e838189aab39c79c177c5 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Fri, 22 Nov 2019 00:31:10 -0800
Subject: Improve the character_offset code.

---
 runtime/lua/vim/lsp/util.lua | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 94b4223a20..e2a8748a20 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -11,14 +11,6 @@ end
 
 local list_extend = vim.list_extend
 
-local function ok_or_nil(status, ...)
-  if not status then return end
-  return ...
-end
-local function npcall(fn, ...)
-  return ok_or_nil(pcall(fn, ...))
-end
-
 --- Find the longest shared prefix between prefix and word.
 -- e.g. remove_prefix("123tes", "testing") == "ting"
 local function remove_prefix(prefix, word)
@@ -668,9 +660,11 @@ end
 -- @param col 0-indexed byte offset in line
 function M.character_offset(buf, row, col)
   local line = api.nvim_buf_get_lines(buf, row, row+1, true)[1]
-  -- TODO(ashkan) is there a better way to handle col being past line length?
   -- If the col is past the EOL, use the line length.
-  return npcall(str_utfindex, line, col) or str_utfindex(line)
+  if col > #line then
+    return str_utfindex(line)
+  end
+  return str_utfindex(line, col)
 end
 
 return M
-- 
cgit 


From d410812311f7b462420690455914ea1316953b3a Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Sat, 23 Nov 2019 16:14:24 -0800
Subject: UI tweaks.

- Hide diagnostics on client exit
- Stop insert on popup focus.
- Hide popup on insertchar (for signature_help)
---
 runtime/lua/vim/lsp.lua      | 12 +++++++++++-
 runtime/lua/vim/lsp/buf.lua  |  8 ++++++--
 runtime/lua/vim/lsp/util.lua |  5 +++--
 3 files changed, 20 insertions(+), 5 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 880d811647..7076db68d3 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -343,9 +343,19 @@ function lsp.start_client(config)
   function handlers.on_exit(code, signal)
     active_clients[client_id] = nil
     uninitialized_clients[client_id] = nil
-    for _, client_ids in pairs(all_buffer_active_clients) do
+    local active_buffers = {}
+    for bufnr, client_ids in pairs(all_buffer_active_clients) do
+      if client_ids[client_id] then
+        table.insert(active_buffers, bufnr)
+      end
       client_ids[client_id] = nil
     end
+    -- Buffer level cleanup
+    vim.schedule(function()
+      for _, bufnr in ipairs(active_buffers) do
+        util.buf_clear_diagnostics(bufnr)
+      end
+    end)
     if config.on_exit then
       pcall(config.on_exit, code, signal, client_id)
     end
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index b4e0b9cbfc..79d43fda4a 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -51,7 +51,9 @@ local function focusable_preview(method, params, fn)
   do
     local win = find_window_by_var(method, bufnr)
     if win then
-      return api.nvim_set_current_win(win)
+      api.nvim_set_current_win(win)
+      api.nvim_command("stopinsert")
+      return
     end
   end
   return request(method, params, function(_, _, result, _)
@@ -234,7 +236,9 @@ end
 function M.signature_help()
   local params = util.make_position_params()
   focusable_preview('textDocument/signatureHelp', params, function(result)
-    if not (result and result.signatures and result.signatures[1]) then return end
+    if not (result and result.signatures and result.signatures[1]) then
+      return { 'No signature available' }
+    end
 
     -- TODO show empty popup when signatures is empty?
     local lines = signature_help_to_preview_contents(result)
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index e2a8748a20..0c53494f02 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -104,7 +104,7 @@ function M.apply_text_edits(text_edits, bufnr)
     local e = cleaned[i]
     local A = {e.A[1] - start_line, e.A[2]}
     local B = {e.B[1] - start_line, e.B[2]}
-    M.set_lines(lines, A, B, e.lines)
+    lines = M.set_lines(lines, A, B, e.lines)
   end
   if set_eol and #lines[#lines] == 0 then
     table.remove(lines)
@@ -340,7 +340,8 @@ function M.open_floating_preview(contents, filetype, opts)
   end
   api.nvim_buf_set_lines(floating_bufnr, 0, -1, true, contents)
   api.nvim_buf_set_option(floating_bufnr, 'modifiable', false)
-  api.nvim_command("autocmd CursorMoved,BufHidden <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
+  -- TODO make InsertCharPre disappearing optional?
+  api.nvim_command("autocmd CursorMoved,BufHidden,InsertCharPre <buffer> ++once lua pcall(vim.api.nvim_win_close, "..floating_winnr..", true)")
   return floating_bufnr, floating_winnr
 end
 
-- 
cgit 


From d0d38fc36e0c1602186aa540417070fa6c1e2746 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Sun, 24 Nov 2019 02:28:48 -0800
Subject: Lua: vim.env, vim.{g,v,w,bo,wo} #11442

- Add vim variable meta accessors: vim.env, vim.{g,v,w,bo,wo}
- Redo gen_char_blob to generate multiple blobs instead of just one
  so that multiple Lua modules can be inlined.
- Reorder vim.lua inclusion so that it can use previously defined C
  functions and utility functions like vim.shared and vim.inspect things.
- Inline shared.lua into nvim, but also keep it available in runtime.
---
 runtime/lua/vim/shared.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index ff89acc524..6aa5f3bd9b 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -4,7 +4,7 @@
 -- test-suite. If, in the future, Nvim itself is used to run the test-suite
 -- instead of "vanilla Lua", these functions could move to src/nvim/lua/vim.lua
 
-local vim = {}
+local vim = vim or {}
 
 --- Returns a deep copy of the given object. Non-table objects are copied as
 --- in a typical Lua assignment, whereas table objects are copied recursively.
-- 
cgit 


From b35f6aa9dd686d082405132e3455cd0aff334361 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Sun, 24 Nov 2019 03:01:18 -0800
Subject: Add support for textDocument/references.

Add set_qflist and set_loclist.
- Also add locations_to_items, which calculates byte offsets for
character positions in files and avoids unnecessary operations.
---
 runtime/lua/vim/lsp/buf.lua               | 15 ++++++
 runtime/lua/vim/lsp/default_callbacks.lua |  2 +-
 runtime/lua/vim/lsp/util.lua              | 80 +++++++++++++++++++++++--------
 3 files changed, 77 insertions(+), 20 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 79d43fda4a..51295e5570 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -1,3 +1,4 @@
+local vim = vim
 local validate = vim.validate
 local api = vim.api
 local vfn = vim.fn
@@ -330,5 +331,19 @@ function M.rename(new_name)
   end)
 end
 
+function M.references(context)
+  validate { context = { context, 't', true } }
+  local params = util.make_position_params()
+  params.context = context or {
+    includeDeclaration = true;
+  }
+  params[vim.type_idx] = vim.types.dictionary
+  request('textDocument/references', params, function(_, _, result)
+    if not result then return end
+    util.set_qflist(result)
+    vim.api.nvim_command("copen")
+  end)
+end
+
 return M
 -- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
index d58280e0f2..2a891e7d1d 100644
--- a/runtime/lua/vim/lsp/default_callbacks.lua
+++ b/runtime/lua/vim/lsp/default_callbacks.lua
@@ -31,7 +31,7 @@ M['textDocument/publishDiagnostics'] = function(_, _, result)
   util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
   util.buf_diagnostics_underline(bufnr, result.diagnostics)
   util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
-  -- util.buf_loclist(bufnr, result.diagnostics)
+  -- util.set_loclist(result.diagnostics)
 end
 
 local function log_message(_, _, result, client_id)
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 0c53494f02..2dfcdfc70c 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -1,4 +1,5 @@
 local protocol = require 'vim.lsp.protocol'
+local vim = vim
 local validate = vim.validate
 local api = vim.api
 
@@ -573,30 +574,71 @@ do
   end
 end
 
-function M.buf_loclist(bufnr, locations)
-  local targetwin
-  for _, winnr in ipairs(api.nvim_list_wins()) do
-    local winbuf = api.nvim_win_get_buf(winnr)
-    if winbuf == bufnr then
-      targetwin = winnr
-      break
-    end
-  end
-  if not targetwin then return end
+local position_sort = sort_by_key(function(v)
+  return {v.line, v.character}
+end)
 
+-- Returns the items with the byte position calculated correctly and in sorted
+-- order.
+function M.locations_to_items(locations)
   local items = {}
-  local path = api.nvim_buf_get_name(bufnr)
+  local grouped = setmetatable({}, {
+    __index = function(t, k)
+      local v = {}
+      rawset(t, k, v)
+      return v
+    end;
+  })
   for _, d in ipairs(locations) do
-    -- TODO: URL parsing here?
     local start = d.range.start
-    table.insert(items, {
-        filename = path,
-        lnum = start.line + 1,
-        col = start.character + 1,
-        text = d.message,
-    })
+    local fname = assert(vim.uri_to_fname(d.uri))
+    table.insert(grouped[fname], start)
+  end
+  local keys = vim.tbl_keys(grouped)
+  table.sort(keys)
+  -- TODO(ashkan) I wish we could do this lazily.
+  for _, fname in ipairs(keys) do
+    local rows = grouped[fname]
+    table.sort(rows, position_sort)
+    local i = 0
+    for line in io.lines(fname) do
+      for _, pos in ipairs(rows) do
+        local row = pos.line
+        if i == row then
+          local col
+          if pos.character > #line then
+            col = #line
+          else
+            col =  vim.str_byteindex(line, pos.character)
+          end
+          table.insert(items, {
+            filename = fname,
+            lnum = row + 1,
+            col = col + 1;
+          })
+        end
+      end
+      i = i + 1
+    end
   end
-  vim.fn.setloclist(targetwin, items, ' ', 'Language Server')
+  return items
+end
+
+-- locations is Location[]
+-- Only sets for the current window.
+function M.set_loclist(locations)
+  vim.fn.setloclist(0, {}, ' ', {
+    title = 'Language Server';
+    items = M.locations_to_items(locations);
+  })
+end
+
+-- locations is Location[]
+function M.set_qflist(locations)
+  vim.fn.setqflist({}, ' ', {
+    title = 'Language Server';
+    items = M.locations_to_items(locations);
+  })
 end
 
 -- Remove empty lines from the beginning and end.
-- 
cgit 


From a9036502dca7191c8ada70367e44c398d48dd94a Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Sun, 24 Nov 2019 03:14:03 -0800
Subject: Bring vim into local scope

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

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 7076db68d3..928d19177a 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -4,6 +4,7 @@ local lsp_rpc = require 'vim.lsp.rpc'
 local protocol = require 'vim.lsp.protocol'
 local util = require 'vim.lsp.util'
 
+local vim = vim
 local nvim_err_writeln, nvim_buf_get_lines, nvim_command, nvim_buf_get_option
   = vim.api.nvim_err_writeln, vim.api.nvim_buf_get_lines, vim.api.nvim_command, vim.api.nvim_buf_get_option
 local uv = vim.loop
-- 
cgit 


From fd5710ae9a3bcbc0f9cbb71de9e39253350ff09c Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 25 Nov 2019 01:08:02 -0800
Subject: doc + extmarks tweaks #11421

- nvim_buf_get_extmarks: rename "amount" => "limit"
- rename `set_extmark_index_from_obj`
---
 runtime/lua/vim/shared.lua | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 1912d3708d..631dd04c35 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -226,16 +226,17 @@ function vim.tbl_add_reverse_lookup(o)
   return o
 end
 
--- Extends a list-like table with the values of another list-like table.
---
--- NOTE: This *mutates* dst!
--- @see |extend()|
---
--- @param dst list which will be modified and appended to.
--- @param src list from which values will be inserted.
--- @param start Start index on src. defaults to 1
--- @param finish Final index on src. defaults to #src
--- @returns dst
+--- Extends a list-like table with the values of another list-like table.
+---
+--- NOTE: This mutates dst!
+---
+--@see |vim.tbl_extend()|
+---
+--@param dst list which will be modified and appended to.
+--@param src list from which values will be inserted.
+--@param start Start index on src. defaults to 1
+--@param finish Final index on src. defaults to #src
+--@returns dst
 function vim.list_extend(dst, src, start, finish)
   vim.validate {
     dst = {dst, 't'};
-- 
cgit 


From 6e8c5779cf960893850501e4871dc9be671db298 Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Tue, 26 Nov 2019 05:59:40 -0800
Subject: LSP: Move default buf callbacks to vim.lsp.callbacks (#11452)

- In the process, refactored focusable_preview to a util function.
- Add text for locations_to_items of the current line.
- Improve location callback to handle multiple return values by using
set_qflist.
- Remove update_tagstack and leave note for future travelers.
---
 runtime/lua/vim/lsp.lua                   |   6 +-
 runtime/lua/vim/lsp/buf.lua               | 253 +++---------------------------
 runtime/lua/vim/lsp/callbacks.lua         | 223 ++++++++++++++++++++++++++
 runtime/lua/vim/lsp/default_callbacks.lua |  69 --------
 runtime/lua/vim/lsp/util.lua              |  56 ++++++-
 5 files changed, 300 insertions(+), 307 deletions(-)
 create mode 100644 runtime/lua/vim/lsp/callbacks.lua
 delete mode 100644 runtime/lua/vim/lsp/default_callbacks.lua

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index 928d19177a..82f4fda66f 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -1,4 +1,4 @@
-local default_callbacks = require 'vim.lsp.default_callbacks'
+local default_callbacks = require 'vim.lsp.callbacks'
 local log = require 'vim.lsp.log'
 local lsp_rpc = require 'vim.lsp.rpc'
 local protocol = require 'vim.lsp.protocol'
@@ -13,7 +13,7 @@ local validate = vim.validate
 
 local lsp = {
   protocol = protocol;
-  default_callbacks = default_callbacks;
+  callbacks = default_callbacks;
   buf = require'vim.lsp.buf';
   util = util;
   -- Allow raw RPC access.
@@ -469,7 +469,7 @@ function lsp.start_client(config)
   function client.request(method, params, callback)
     if not callback then
       callback = resolve_callback(method)
-        or error(string.format("request callback is empty and no default was found for client %s", client.name))
+        or error("not found: request callback for client "..client.name)
     end
     local _ = log.debug() and log.debug(log_prefix, "client.request", client_id, method, params, callback)
     -- TODO keep these checks or just let it go anyway?
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 51295e5570..a6a05fb095 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -3,7 +3,6 @@ local validate = vim.validate
 local api = vim.api
 local vfn = vim.fn
 local util = require 'vim.lsp.util'
-local log = require 'vim.lsp.log'
 local list_extend = vim.list_extend
 
 local M = {}
@@ -16,270 +15,68 @@ local function npcall(fn, ...)
   return ok_or_nil(pcall(fn, ...))
 end
 
-local function err_message(...)
-  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
-  api.nvim_command("redraw")
-end
-
-local function find_window_by_var(name, value)
-  for _, win in ipairs(api.nvim_list_wins()) do
-    if npcall(api.nvim_win_get_var, win, name) == value then
-      return win
-    end
-  end
-end
-
 local function request(method, params, callback)
-  --  TODO(ashkan) enable this.
-  --  callback = vim.lsp.default_callbacks[method] or callback
   validate {
     method = {method, 's'};
-    callback = {callback, 'f'};
+    callback = {callback, 'f', true};
   }
-  return vim.lsp.buf_request(0, method, params, function(err, _, result, client_id)
-    local _ = log.debug() and log.debug("vim.lsp.buf", method, client_id, err, result)
-    if err then error(tostring(err)) end
-    return callback(err, method, result, client_id)
-  end)
-end
-
-local function focusable_preview(method, params, fn)
-  if npcall(api.nvim_win_get_var, 0, method) then
-    return api.nvim_command("wincmd p")
-  end
-
-  local bufnr = api.nvim_get_current_buf()
-  do
-    local win = find_window_by_var(method, bufnr)
-    if win then
-      api.nvim_set_current_win(win)
-      api.nvim_command("stopinsert")
-      return
-    end
-  end
-  return request(method, params, function(_, _, result, _)
-      -- TODO(ashkan) could show error in preview...
-    local lines, filetype, opts = fn(result)
-    if lines then
-      local _, winnr = util.open_floating_preview(lines, filetype, opts)
-      api.nvim_win_set_var(winnr, method, bufnr)
-    end
-  end)
+  return vim.lsp.buf_request(0, method, params, callback)
 end
 
 function M.hover()
   local params = util.make_position_params()
-  focusable_preview('textDocument/hover', params, function(result)
-    if not (result and result.contents) then return end
-
-    local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
-    markdown_lines = util.trim_empty_lines(markdown_lines)
-    if vim.tbl_isempty(markdown_lines) then
-      return { 'No information available' }
-    end
-    return markdown_lines, util.try_trim_markdown_code_blocks(markdown_lines)
-  end)
+  request('textDocument/hover', params)
 end
 
 function M.peek_definition()
   local params = util.make_position_params()
-  request('textDocument/peekDefinition', params, function(_, _, result, _)
-    if not (result and result[1]) then return end
-    local loc = result[1]
-    local bufnr = vim.uri_to_bufnr(loc.uri) or error("couldn't find file "..tostring(loc.uri))
-    local start = loc.range.start
-    local finish = loc.range["end"]
-    util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
-    local headbuf = util.open_floating_preview({"Peek:"}, nil, {
-      offset_y = -(finish.line - start.line);
-      width = finish.character - start.character + 2;
-    })
-    -- TODO(ashkan) change highlight group?
-    api.nvim_buf_add_highlight(headbuf, -1, 'Keyword', 0, -1)
-  end)
+  request('textDocument/peekDefinition', params)
 end
 
 
-local function update_tagstack()
-  local bufnr = api.nvim_get_current_buf()
-  local line = vfn.line('.')
-  local col = vfn.col('.')
-  local tagname = vfn.expand('<cWORD>')
-  local item = { bufnr = bufnr, from = { bufnr, line, col, 0 }, tagname = tagname }
-  local winid = vfn.win_getid()
-  local tagstack = vfn.gettagstack(winid)
-  local action
-  if tagstack.length == tagstack.curidx then
-    action = 'r'
-    tagstack.items[tagstack.curidx] = item
-  elseif tagstack.length > tagstack.curidx then
-    action = 'r'
-    if tagstack.curidx > 1 then
-      tagstack.items = table.insert(tagstack.items[tagstack.curidx - 1], item)
-    else
-      tagstack.items = { item }
-    end
-  else
-    action = 'a'
-    tagstack.items = { item }
-  end
-  tagstack.curidx = tagstack.curidx + 1
-  vfn.settagstack(winid, tagstack, action)
-end
-local function handle_location(result)
-  -- We can sometimes get a list of locations, so set the first value as the
-  -- only value we want to handle
-  -- TODO(ashkan) was this correct^? We could use location lists.
-  if result[1] ~= nil then
-    result = result[1]
-  end
-  if result.uri == nil then
-    err_message('[LSP] Could not find a valid location')
-    return
-  end
-  local bufnr = vim.uri_to_bufnr(result.uri)
-  update_tagstack()
-  api.nvim_set_current_buf(bufnr)
-  local row = result.range.start.line
-  local col = result.range.start.character
-  local line = api.nvim_buf_get_lines(0, row, row+1, true)[1]
-  col = #line:sub(1, col)
-  api.nvim_win_set_cursor(0, {row + 1, col})
-  return true
-end
-local function location_callback(_, method, result)
-  if result == nil or vim.tbl_isempty(result) then
-    local _ = log.info() and log.info(method, 'No location found')
-    return nil
-  end
-  return handle_location(result)
-end
-
 function M.declaration()
   local params = util.make_position_params()
-  request('textDocument/declaration', params, location_callback)
+  request('textDocument/declaration', params)
 end
 
 function M.definition()
   local params = util.make_position_params()
-  request('textDocument/definition', params, location_callback)
+  request('textDocument/definition', params)
 end
 
 function M.type_definition()
   local params = util.make_position_params()
-  request('textDocument/typeDefinition', params, location_callback)
+  request('textDocument/typeDefinition', params)
 end
 
 function M.implementation()
   local params = util.make_position_params()
-  request('textDocument/implementation', params, location_callback)
-end
-
---- Convert SignatureHelp response to preview contents.
--- https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_signatureHelp
-local function signature_help_to_preview_contents(input)
-  if not input.signatures then
-    return
-  end
-  --The active signature. If omitted or the value lies outside the range of
-  --`signatures` the value defaults to zero or is ignored if `signatures.length
-  --=== 0`. Whenever possible implementors should make an active decision about
-  --the active signature and shouldn't rely on a default value.
-  local contents = {}
-  local active_signature = input.activeSignature or 0
-  -- If the activeSignature is not inside the valid range, then clip it.
-  if active_signature >= #input.signatures then
-    active_signature = 0
-  end
-  local signature = input.signatures[active_signature + 1]
-  if not signature then
-    return
-  end
-  list_extend(contents, vim.split(signature.label, '\n', true))
-  if signature.documentation then
-    util.convert_input_to_markdown_lines(signature.documentation, contents)
-  end
-  if input.parameters then
-    local active_parameter = input.activeParameter or 0
-    -- If the activeParameter is not inside the valid range, then clip it.
-    if active_parameter >= #input.parameters then
-      active_parameter = 0
-    end
-    local parameter = signature.parameters and signature.parameters[active_parameter]
-    if parameter then
-      --[=[
-      --Represents a parameter of a callable-signature. A parameter can
-      --have a label and a doc-comment.
-      interface ParameterInformation {
-        --The label of this parameter information.
-        --
-        --Either a string or an inclusive start and exclusive end offsets within its containing
-        --signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
-        --string representation as `Position` and `Range` does.
-        --
-        --*Note*: a label of type string should be a substring of its containing signature label.
-        --Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
-        label: string | [number, number];
-        --The human-readable doc-comment of this parameter. Will be shown
-        --in the UI but can be omitted.
-        documentation?: string | MarkupContent;
-      }
-      --]=]
-      -- TODO highlight parameter
-      if parameter.documentation then
-        util.convert_input_to_markdown_lines(parameter.documentation, contents)
-      end
-    end
-  end
-  return contents
+  request('textDocument/implementation', params)
 end
 
 function M.signature_help()
   local params = util.make_position_params()
-  focusable_preview('textDocument/signatureHelp', params, function(result)
-    if not (result and result.signatures and result.signatures[1]) then
-      return { 'No signature available' }
-    end
-
-    -- TODO show empty popup when signatures is empty?
-    local lines = signature_help_to_preview_contents(result)
-    lines = util.trim_empty_lines(lines)
-    if vim.tbl_isempty(lines) then
-      return { 'No signature available' }
-    end
-    return lines, util.try_trim_markdown_code_blocks(lines)
-  end)
+  request('textDocument/signatureHelp', params)
 end
 
 -- TODO(ashkan) ?
 function M.completion(context)
   local params = util.make_position_params()
   params.context = context
-  return request('textDocument/completion', params, function(_, _, result)
-    if vim.tbl_isempty(result or {}) then return end
-    local row, col = unpack(api.nvim_win_get_cursor(0))
-    local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
-    local line_to_cursor = line:sub(col+1)
-
-    local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
-    vim.fn.complete(col, matches)
-  end)
+  return request('textDocument/completion', params)
 end
 
 function M.formatting(options)
   validate { options = {options, 't', true} }
   options = vim.tbl_extend('keep', options or {}, {
-    tabSize = api.nvim_buf_get_option(0, 'tabstop');
-    insertSpaces = api.nvim_buf_get_option(0, 'expandtab');
+    tabSize = vim.bo.tabstop;
+    insertSpaces = vim.bo.expandtab;
   })
   local params = {
     textDocument = { uri = vim.uri_from_bufnr(0) };
     options = options;
   }
-  return request('textDocument/formatting', params, function(_, _, result)
-    if not result then return end
-    util.apply_text_edits(result)
-  end)
+  return request('textDocument/formatting', params)
 end
 
 function M.range_formatting(options, start_pos, end_pos)
@@ -289,8 +86,8 @@ function M.range_formatting(options, start_pos, end_pos)
     end_pos = {end_pos, 't', true};
   }
   options = vim.tbl_extend('keep', options or {}, {
-    tabSize = api.nvim_buf_get_option(0, 'tabstop');
-    insertSpaces = api.nvim_buf_get_option(0, 'expandtab');
+    tabSize = vim.bo.tabstop;
+    insertSpaces = vim.bo.expandtab;
   })
   local A = list_extend({}, start_pos or api.nvim_buf_get_mark(0, '<'))
   local B = list_extend({}, end_pos or api.nvim_buf_get_mark(0, '>'))
@@ -299,10 +96,10 @@ function M.range_formatting(options, start_pos, end_pos)
   B[1] = B[1] - 1
   -- account for encoding.
   if A[2] > 0 then
-    A = {A[1], util.character_offset(0, unpack(A))}
+    A = {A[1], util.character_offset(0, A[1], A[2])}
   end
   if B[2] > 0 then
-    B = {B[1], util.character_offset(0, unpack(B))}
+    B = {B[1], util.character_offset(0, B[1], B[2])}
   end
   local params = {
     textDocument = { uri = vim.uri_from_bufnr(0) };
@@ -312,10 +109,7 @@ function M.range_formatting(options, start_pos, end_pos)
     };
     options = options;
   }
-  return request('textDocument/rangeFormatting', params, function(_, _, result)
-    if not result then return end
-    util.apply_text_edits(result)
-  end)
+  return request('textDocument/rangeFormatting', params)
 end
 
 function M.rename(new_name)
@@ -325,10 +119,7 @@ function M.rename(new_name)
   new_name = new_name or npcall(vfn.input, "New Name: ")
   if not (new_name and #new_name > 0) then return end
   params.newName = new_name
-  request('textDocument/rename', params, function(_, _, result)
-    if not result then return end
-    util.apply_workspace_edit(result)
-  end)
+  request('textDocument/rename', params)
 end
 
 function M.references(context)
@@ -338,11 +129,7 @@ function M.references(context)
     includeDeclaration = true;
   }
   params[vim.type_idx] = vim.types.dictionary
-  request('textDocument/references', params, function(_, _, result)
-    if not result then return end
-    util.set_qflist(result)
-    vim.api.nvim_command("copen")
-  end)
+  request('textDocument/references', params)
 end
 
 return M
diff --git a/runtime/lua/vim/lsp/callbacks.lua b/runtime/lua/vim/lsp/callbacks.lua
new file mode 100644
index 0000000000..4fc3f74519
--- /dev/null
+++ b/runtime/lua/vim/lsp/callbacks.lua
@@ -0,0 +1,223 @@
+local log = require 'vim.lsp.log'
+local protocol = require 'vim.lsp.protocol'
+local util = require 'vim.lsp.util'
+local vim = vim
+local api = vim.api
+
+local M = {}
+
+local function err_message(...)
+  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
+  api.nvim_command("redraw")
+end
+
+M['workspace/applyEdit'] = function(_, _, workspace_edit)
+  if not workspace_edit then return end
+  -- TODO(ashkan) Do something more with label?
+  if workspace_edit.label then
+    print("Workspace edit", workspace_edit.label)
+  end
+  util.apply_workspace_edit(workspace_edit.edit)
+end
+
+M['textDocument/publishDiagnostics'] = function(_, _, result)
+  if not result then return end
+  local uri = result.uri
+  local bufnr = vim.uri_to_bufnr(uri)
+  if not bufnr then
+    err_message("LSP.publishDiagnostics: Couldn't find buffer for ", uri)
+    return
+  end
+  util.buf_clear_diagnostics(bufnr)
+  util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
+  util.buf_diagnostics_underline(bufnr, result.diagnostics)
+  util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
+  -- util.set_loclist(result.diagnostics)
+end
+
+M['textDocument/references'] = function(_, _, result)
+  if not result then return end
+  util.set_qflist(result)
+  api.nvim_command("copen")
+  api.nvim_command("wincmd p")
+end
+
+M['textDocument/rename'] = function(_, _, result)
+  if not result then return end
+  util.apply_workspace_edit(result)
+end
+
+M['textDocument/rangeFormatting'] = function(_, _, result)
+  if not result then return end
+  util.apply_text_edits(result)
+end
+
+M['textDocument/formatting'] = function(_, _, result)
+  if not result then return end
+  util.apply_text_edits(result)
+end
+
+M['textDocument/completion'] = function(_, _, result)
+  if vim.tbl_isempty(result or {}) then return end
+  local row, col = unpack(api.nvim_win_get_cursor(0))
+  local line = assert(api.nvim_buf_get_lines(0, row-1, row, false)[1])
+  local line_to_cursor = line:sub(col+1)
+
+  local matches = util.text_document_completion_list_to_complete_items(result, line_to_cursor)
+  vim.fn.complete(col, matches)
+end
+
+M['textDocument/hover'] = function(_, method, result)
+  util.focusable_preview(method, function()
+    if not (result and result.contents) then
+      return { 'No information available' }
+    end
+    local markdown_lines = util.convert_input_to_markdown_lines(result.contents)
+    markdown_lines = util.trim_empty_lines(markdown_lines)
+    if vim.tbl_isempty(markdown_lines) then
+      return { 'No information available' }
+    end
+    return markdown_lines, util.try_trim_markdown_code_blocks(markdown_lines)
+  end)
+end
+
+local function location_callback(_, method, result)
+  if result == nil or vim.tbl_isempty(result) then
+    local _ = log.info() and log.info(method, 'No location found')
+    return nil
+  end
+  util.jump_to_location(result[1])
+  if #result > 1 then
+    util.set_qflist(result)
+    api.nvim_command("copen")
+    api.nvim_command("wincmd p")
+  end
+end
+
+M['textDocument/declaration'] = location_callback
+M['textDocument/definition'] = location_callback
+M['textDocument/typeDefinition'] = location_callback
+M['textDocument/implementation'] = location_callback
+
+--- Convert SignatureHelp response to preview contents.
+-- https://microsoft.github.io/language-server-protocol/specifications/specification-3-14/#textDocument_signatureHelp
+local function signature_help_to_preview_contents(input)
+  if not input.signatures then
+    return
+  end
+  --The active signature. If omitted or the value lies outside the range of
+  --`signatures` the value defaults to zero or is ignored if `signatures.length
+  --=== 0`. Whenever possible implementors should make an active decision about
+  --the active signature and shouldn't rely on a default value.
+  local contents = {}
+  local active_signature = input.activeSignature or 0
+  -- If the activeSignature is not inside the valid range, then clip it.
+  if active_signature >= #input.signatures then
+    active_signature = 0
+  end
+  local signature = input.signatures[active_signature + 1]
+  if not signature then
+    return
+  end
+  vim.list_extend(contents, vim.split(signature.label, '\n', true))
+  if signature.documentation then
+    util.convert_input_to_markdown_lines(signature.documentation, contents)
+  end
+  if input.parameters then
+    local active_parameter = input.activeParameter or 0
+    -- If the activeParameter is not inside the valid range, then clip it.
+    if active_parameter >= #input.parameters then
+      active_parameter = 0
+    end
+    local parameter = signature.parameters and signature.parameters[active_parameter]
+    if parameter then
+      --[=[
+      --Represents a parameter of a callable-signature. A parameter can
+      --have a label and a doc-comment.
+      interface ParameterInformation {
+        --The label of this parameter information.
+        --
+        --Either a string or an inclusive start and exclusive end offsets within its containing
+        --signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
+        --string representation as `Position` and `Range` does.
+        --
+        --*Note*: a label of type string should be a substring of its containing signature label.
+        --Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+        label: string | [number, number];
+        --The human-readable doc-comment of this parameter. Will be shown
+        --in the UI but can be omitted.
+        documentation?: string | MarkupContent;
+      }
+      --]=]
+      -- TODO highlight parameter
+      if parameter.documentation then
+        util.convert_input_to_markdown_lines(parameter.documentation, contents)
+      end
+    end
+  end
+  return contents
+end
+
+M['textDocument/signatureHelp'] = function(_, method, result)
+  util.focusable_preview(method, function()
+    if not (result and result.signatures and result.signatures[1]) then
+      return { 'No signature available' }
+    end
+    -- TODO show popup when signatures is empty?
+    local lines = signature_help_to_preview_contents(result)
+    lines = util.trim_empty_lines(lines)
+    if vim.tbl_isempty(lines) then
+      return { 'No signature available' }
+    end
+    return lines, util.try_trim_markdown_code_blocks(lines)
+  end)
+end
+
+M['textDocument/peekDefinition'] = function(_, _, result, _)
+  if not (result and result[1]) then return end
+  local loc = result[1]
+  local bufnr = vim.uri_to_bufnr(loc.uri) or error("not found: "..tostring(loc.uri))
+  local start = loc.range.start
+  local finish = loc.range["end"]
+  util.open_floating_peek_preview(bufnr, start, finish, { offset_x = 1 })
+  local headbuf = util.open_floating_preview({"Peek:"}, nil, {
+    offset_y = -(finish.line - start.line);
+    width = finish.character - start.character + 2;
+  })
+  -- TODO(ashkan) change highlight group?
+  api.nvim_buf_add_highlight(headbuf, -1, 'Keyword', 0, -1)
+end
+
+local function log_message(_, _, result, client_id)
+  local message_type = result.type
+  local message = result.message
+  local client = vim.lsp.get_client_by_id(client_id)
+  local client_name = client and client.name or string.format("id=%d", client_id)
+  if not client then
+    err_message("LSP[", client_name, "] client has shut down after sending the message")
+  end
+  if message_type == protocol.MessageType.Error then
+    err_message("LSP[", client_name, "] ", message)
+  else
+    local message_type_name = protocol.MessageType[message_type]
+    api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
+  end
+  return result
+end
+
+M['window/showMessage'] = log_message
+M['window/logMessage'] = log_message
+
+-- Add boilerplate error validation and logging for all of these.
+for k, fn in pairs(M) do
+  M[k] = function(err, method, params, client_id)
+    local _ = log.debug() and log.debug('default_callback', method, { params = params, client_id = client_id, err = err })
+    if err then
+      error(tostring(err))
+    end
+    return fn(err, method, params, client_id)
+  end
+end
+
+return M
+-- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/default_callbacks.lua b/runtime/lua/vim/lsp/default_callbacks.lua
deleted file mode 100644
index 2a891e7d1d..0000000000
--- a/runtime/lua/vim/lsp/default_callbacks.lua
+++ /dev/null
@@ -1,69 +0,0 @@
-local log = require 'vim.lsp.log'
-local protocol = require 'vim.lsp.protocol'
-local util = require 'vim.lsp.util'
-local api = vim.api
-
-local M = {}
-
-local function err_message(...)
-  api.nvim_err_writeln(table.concat(vim.tbl_flatten{...}))
-  api.nvim_command("redraw")
-end
-
-M['workspace/applyEdit'] = function(_, _, workspace_edit)
-  if not workspace_edit then return end
-  -- TODO(ashkan) Do something more with label?
-  if workspace_edit.label then
-    print("Workspace edit", workspace_edit.label)
-  end
-  util.apply_workspace_edit(workspace_edit.edit)
-end
-
-M['textDocument/publishDiagnostics'] = function(_, _, result)
-  if not result then return end
-  local uri = result.uri
-  local bufnr = vim.uri_to_bufnr(uri)
-  if not bufnr then
-    err_message("LSP.publishDiagnostics: Couldn't find buffer for ", uri)
-    return
-  end
-  util.buf_clear_diagnostics(bufnr)
-  util.buf_diagnostics_save_positions(bufnr, result.diagnostics)
-  util.buf_diagnostics_underline(bufnr, result.diagnostics)
-  util.buf_diagnostics_virtual_text(bufnr, result.diagnostics)
-  -- util.set_loclist(result.diagnostics)
-end
-
-local function log_message(_, _, result, client_id)
-  local message_type = result.type
-  local message = result.message
-  local client = vim.lsp.get_client_by_id(client_id)
-  local client_name = client and client.name or string.format("id=%d", client_id)
-  if not client then
-    err_message("LSP[", client_name, "] client has shut down after sending the message")
-  end
-  if message_type == protocol.MessageType.Error then
-    err_message("LSP[", client_name, "] ", message)
-  else
-    local message_type_name = protocol.MessageType[message_type]
-    api.nvim_out_write(string.format("LSP[%s][%s] %s\n", client_name, message_type_name, message))
-  end
-  return result
-end
-
-M['window/showMessage'] = log_message
-M['window/logMessage'] = log_message
-
--- Add boilerplate error validation and logging for all of these.
-for k, fn in pairs(M) do
-  M[k] = function(err, method, params, client_id)
-    local _ = log.debug() and log.debug('default_callback', method, { params = params, client_id = client_id, err = err })
-    if err then
-      error(tostring(err))
-    end
-    return fn(err, method, params, client_id)
-  end
-end
-
-return M
--- vim:sw=2 ts=2 et
diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 2dfcdfc70c..6e0d3fd4ee 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -2,6 +2,7 @@ local protocol = require 'vim.lsp.protocol'
 local vim = vim
 local validate = vim.validate
 local api = vim.api
+local list_extend = vim.list_extend
 
 local M = {}
 
@@ -10,7 +11,13 @@ local function split_lines(value)
   return split(value, '\n', true)
 end
 
-local list_extend = vim.list_extend
+local function ok_or_nil(status, ...)
+  if not status then return end
+  return ...
+end
+local function npcall(fn, ...)
+  return ok_or_nil(pcall(fn, ...))
+end
 
 --- Find the longest shared prefix between prefix and word.
 -- e.g. remove_prefix("123tes", "testing") == "ting"
@@ -303,6 +310,50 @@ function M.make_floating_popup_options(width, height, opts)
   }
 end
 
+function M.jump_to_location(location)
+  if location.uri == nil then return end
+  local bufnr = vim.uri_to_bufnr(location.uri)
+  -- TODO(ashkan) use tagfunc here to update tagstack.
+  api.nvim_set_current_buf(bufnr)
+  local row = location.range.start.line
+  local col = location.range.start.character
+  local line = api.nvim_buf_get_lines(0, row, row+1, true)[1]
+  col = vim.str_byteindex(line, col)
+  api.nvim_win_set_cursor(0, {row + 1, col})
+  return true
+end
+
+local function find_window_by_var(name, value)
+  for _, win in ipairs(api.nvim_list_wins()) do
+    if npcall(api.nvim_win_get_var, win, name) == value then
+      return win
+    end
+  end
+end
+
+-- Check if a window with `unique_name` tagged is associated with the current
+-- buffer. If not, make a new preview.
+--
+-- fn()'s return values will be passed directly to open_floating_preview in the
+-- case that a new floating window should be created.
+function M.focusable_preview(unique_name, fn)
+  if npcall(api.nvim_win_get_var, 0, unique_name) then
+    return api.nvim_command("wincmd p")
+  end
+  local bufnr = api.nvim_get_current_buf()
+  do
+    local win = find_window_by_var(unique_name, bufnr)
+    if win then
+      api.nvim_set_current_win(win)
+      api.nvim_command("stopinsert")
+      return
+    end
+  end
+  local pbufnr, pwinnr = M.open_floating_preview(fn())
+  api.nvim_win_set_var(pwinnr, unique_name, bufnr)
+  return pbufnr, pwinnr
+end
+
 function M.open_floating_preview(contents, filetype, opts)
   validate {
     contents = { contents, 't' };
@@ -609,12 +660,13 @@ function M.locations_to_items(locations)
           if pos.character > #line then
             col = #line
           else
-            col =  vim.str_byteindex(line, pos.character)
+            col = vim.str_byteindex(line, pos.character)
           end
           table.insert(items, {
             filename = fname,
             lnum = row + 1,
             col = col + 1;
+            text = line;
           })
         end
       end
-- 
cgit 


From 950690e48a6ff4788b3ad6c23caa99d253facd57 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Wed, 27 Nov 2019 19:45:03 +0100
Subject: lsp: allow the user to config LspDiagnosticError etc by standard
 means

---
 runtime/lua/vim/lsp/util.lua | 71 ++++++++++----------------------------------
 1 file changed, 15 insertions(+), 56 deletions(-)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index 6e0d3fd4ee..b9990ed082 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -440,6 +440,11 @@ do
 
   local diagnostic_ns = api.nvim_create_namespace("vim_lsp_diagnostics")
 
+  local underline_highlight_name = "LspDiagnosticsUnderline"
+  api.nvim_command(string.format("highlight default %s gui=underline cterm=underline", underline_highlight_name))
+
+  local severity_highlights = {}
+
   local default_severity_highlight = {
     [protocol.DiagnosticSeverity.Error] = { guifg = "Red" };
     [protocol.DiagnosticSeverity.Warning] = { guifg = "Orange" };
@@ -447,60 +452,17 @@ do
     [protocol.DiagnosticSeverity.Hint] = { guifg = "LightGrey" };
   }
 
-  local underline_highlight_name = "LspDiagnosticsUnderline"
-  api.nvim_command(string.format("highlight %s gui=underline cterm=underline", underline_highlight_name))
-
-  local function find_color_rgb(color)
-    local rgb_hex = api.nvim_get_color_by_name(color)
-    validate { color = {color, function() return rgb_hex ~= -1 end, "valid color name"} }
-    return rgb_hex
-  end
-
-  --- Determine whether to use black or white text
-  -- Ref: https://stackoverflow.com/a/1855903/837964
-  -- https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
-  local function color_is_bright(r, g, b)
-    -- Counting the perceptive luminance - human eye favors green color
-    local luminance = (0.299*r + 0.587*g + 0.114*b)/255
-    if luminance > 0.5 then
-      return true -- Bright colors, black font
-    else
-      return false -- Dark colors, white font
-    end
-  end
-
-  local severity_highlights = {}
-
-  function M.set_severity_highlights(highlights)
-    validate {highlights = {highlights, 't'}}
-    for severity, default_color in pairs(default_severity_highlight) do
-      local severity_name = protocol.DiagnosticSeverity[severity]
-      local highlight_name = "LspDiagnostics"..severity_name
-      local hi_info = highlights[severity] or default_color
-      -- Try to fill in the foreground color with a sane default.
-      if not hi_info.guifg and hi_info.guibg then
-        -- TODO(ashkan) move this out when bitop is guaranteed to be included.
-        local bit = require 'bit'
-        local band, rshift = bit.band, bit.rshift
-        local rgb = find_color_rgb(hi_info.guibg)
-        local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
-        hi_info.guifg = is_bright and "Black" or "White"
-      end
-      if not hi_info.ctermfg and hi_info.ctermbg then
-        -- TODO(ashkan) move this out when bitop is guaranteed to be included.
-        local bit = require 'bit'
-        local band, rshift = bit.band, bit.rshift
-        local rgb = find_color_rgb(hi_info.ctermbg)
-        local is_bright = color_is_bright(rshift(rgb, 16), band(rshift(rgb, 8), 0xFF), band(rgb, 0xFF))
-        hi_info.ctermfg = is_bright and "Black" or "White"
-      end
-      local cmd_parts = {"highlight", highlight_name}
-      for k, v in pairs(hi_info) do
-        table.insert(cmd_parts, k.."="..v)
-      end
-      api.nvim_command(table.concat(cmd_parts, ' '))
-      severity_highlights[severity] = highlight_name
+  -- Initialize default severity highlights
+  for severity, hi_info in pairs(default_severity_highlight) do
+    local severity_name = protocol.DiagnosticSeverity[severity]
+    local highlight_name = "LspDiagnostics"..severity_name
+    -- Try to fill in the foreground color with a sane default.
+    local cmd_parts = {"highlight", "default", highlight_name}
+    for k, v in pairs(hi_info) do
+      table.insert(cmd_parts, k.."="..v)
     end
+    api.nvim_command(table.concat(cmd_parts, ' '))
+    severity_highlights[severity] = highlight_name
   end
 
   function M.buf_clear_diagnostics(bufnr)
@@ -509,9 +471,6 @@ do
     api.nvim_buf_clear_namespace(bufnr, diagnostic_ns, 0, -1)
   end
 
-  -- Initialize with the defaults.
-  M.set_severity_highlights(default_severity_highlight)
-
   function M.get_severity_highlight_name(severity)
     return severity_highlights[severity]
   end
-- 
cgit 


From 70b606166640d043fc7b78a52b89ff1bba798b6a Mon Sep 17 00:00:00 2001
From: Ashkan Kiani <ashkan.k.kiani@gmail.com>
Date: Sun, 1 Dec 2019 05:32:55 -0800
Subject: Add vim.startswith and vim.endswith (#11248)

---
 runtime/lua/vim/shared.lua | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 631dd04c35..b5b04d7757 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -320,6 +320,26 @@ function vim.pesc(s)
   return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
 end
 
+--- Test if `prefix` is a prefix of `s` for strings.
+--
+-- @param s String to check
+-- @param prefix Potential prefix
+-- @return boolean True if prefix is a prefix of s
+function vim.startswith(s, prefix)
+  vim.validate { s = {s, 's'}; prefix = {prefix, 's'}; }
+  return s:sub(1, #prefix) == prefix
+end
+
+--- Test if `suffix` is a suffix of `s` for strings.
+--
+-- @param s String to check
+-- @param suffix Potential suffix
+-- @return boolean True if suffix is a suffix of s
+function vim.endswith(s, suffix)
+  vim.validate { s = {s, 's'}; suffix = {suffix, 's'}; }
+  return #suffix == 0 or s:sub(-#suffix) == suffix
+end
+
 --- Validates a parameter specification (types and values).
 ---
 --- Usage example:
-- 
cgit 


From 30ed245d008045a505a87ab21d22ada45dd1f4b5 Mon Sep 17 00:00:00 2001
From: Jakub Łuczyński <doubleloop@users.noreply.github.com>
Date: Sat, 7 Dec 2019 12:34:22 +0100
Subject: LSP: Add jump when calling gotodef (#11521)

---
 runtime/lua/vim/lsp/util.lua | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'runtime/lua')

diff --git a/runtime/lua/vim/lsp/util.lua b/runtime/lua/vim/lsp/util.lua
index b9990ed082..3798b30a46 100644
--- a/runtime/lua/vim/lsp/util.lua
+++ b/runtime/lua/vim/lsp/util.lua
@@ -313,6 +313,8 @@ end
 function M.jump_to_location(location)
   if location.uri == nil then return end
   local bufnr = vim.uri_to_bufnr(location.uri)
+  -- Save position in jumplist
+  vim.cmd "normal! m'"
   -- TODO(ashkan) use tagfunc here to update tagstack.
   api.nvim_set_current_buf(bufnr)
   local row = location.range.start.line
-- 
cgit