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 ++++++++++++++++++++++++++++++++++++++++++
 runtime/plugin/ts_test.vim    |  32 ++++++++++++
 2 files changed, 151 insertions(+)
 create mode 100644 runtime/lua/treesitter_rt.lua
 create mode 100644 runtime/plugin/ts_test.vim

(limited to 'runtime')

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
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
new file mode 100644
index 0000000000..e40e2792e1
--- /dev/null
+++ b/runtime/plugin/ts_test.vim
@@ -0,0 +1,32 @@
+let g:ts_test_path = expand("<sfile>:p:h:h")
+let g:has_ts = v:false
+
+func! TSTest()
+  if g:has_ts
+    return
+  end
+  " TODO: module!
+  lua require'treesitter_rt'
+  lua theparser = create_parser(vim.api.nvim_get_current_buf())
+  let g:has_ts = v:true
+endfunc
+
+func! TSCursor()
+  " disable matchparen
+  NoMatchParen
+  call TSTest()
+  au CursorMoved <buffer> lua ts_cursor()
+  au CursorMovedI <buffer> lua ts_cursor()
+  map <buffer> <Plug>(ts-expand) <cmd>lua ts_expand_node()<cr>
+endfunc
+
+func! TSSyntax()
+  " disable matchparen
+  set syntax=
+  call TSTest()
+  lua ts_syntax()
+endfunc
+
+command! TSTest call TSTest()
+command! TSCursor call TSCursor()
+command! TSSyntax call TSSyntax()
-- 
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')

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 ++++++++++++++++
 runtime/plugin/ts_test.vim       |   3 +-
 4 files changed, 106 insertions(+), 116 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')

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
+
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
index e40e2792e1..d048dbe7c8 100644
--- a/runtime/plugin/ts_test.vim
+++ b/runtime/plugin/ts_test.vim
@@ -6,7 +6,8 @@ func! TSTest()
     return
   end
   " TODO: module!
-  lua require'treesitter_rt'
+  lua require'vim.tree_sitter'
+  lua require'tree_sitter_demo'
   lua theparser = create_parser(vim.api.nvim_get_current_buf())
   let g:has_ts = v:true
 endfunc
-- 
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 +++++++++++++++++++++++-----------------
 runtime/plugin/ts_test.vim       |  3 +--
 3 files changed, 29 insertions(+), 22 deletions(-)

(limited to 'runtime')

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}
+
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
index d048dbe7c8..76318163f6 100644
--- a/runtime/plugin/ts_test.vim
+++ b/runtime/plugin/ts_test.vim
@@ -6,9 +6,8 @@ func! TSTest()
     return
   end
   " TODO: module!
-  lua require'vim.tree_sitter'
+  lua theparser = require'vim.tree_sitter'.create_parser(0)
   lua require'tree_sitter_demo'
-  lua theparser = create_parser(vim.api.nvim_get_current_buf())
   let g:has_ts = v:true
 endfunc
 
-- 
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')

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 +++++---
 runtime/plugin/ts_test.vim      | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

(limited to 'runtime')

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}
 
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
index 76318163f6..9420c2c9d3 100644
--- a/runtime/plugin/ts_test.vim
+++ b/runtime/plugin/ts_test.vim
@@ -6,7 +6,7 @@ func! TSTest()
     return
   end
   " TODO: module!
-  lua theparser = require'vim.tree_sitter'.create_parser(0)
+  lua theparser = vim.tree_sitter.create_parser(0)
   lua require'tree_sitter_demo'
   let g:has_ts = v:true
 endfunc
-- 
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 +++++++++++++++++++++++++++++++++++++++
 runtime/plugin/ts_test.vim       |  4 +--
 5 files changed, 117 insertions(+), 116 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')

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}
+
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
index 9420c2c9d3..15192d8dda 100644
--- a/runtime/plugin/ts_test.vim
+++ b/runtime/plugin/ts_test.vim
@@ -6,8 +6,8 @@ func! TSTest()
     return
   end
   " TODO: module!
-  lua theparser = vim.tree_sitter.create_parser(0)
-  lua require'tree_sitter_demo'
+  lua theparser = vim.treesitter.create_parser(0)
+  lua require'treesitter_demo'
   let g:has_ts = v:true
 endfunc
 
-- 
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')

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')

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 +-
 runtime/plugin/ts_test.vim      | 32 -----------------------
 3 files changed, 1 insertion(+), 91 deletions(-)
 delete mode 100644 runtime/lua/treesitter_demo.lua
 delete mode 100644 runtime/plugin/ts_test.vim

(limited to 'runtime')

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
diff --git a/runtime/plugin/ts_test.vim b/runtime/plugin/ts_test.vim
deleted file mode 100644
index 15192d8dda..0000000000
--- a/runtime/plugin/ts_test.vim
+++ /dev/null
@@ -1,32 +0,0 @@
-let g:ts_test_path = expand("<sfile>:p:h:h")
-let g:has_ts = v:false
-
-func! TSTest()
-  if g:has_ts
-    return
-  end
-  " TODO: module!
-  lua theparser = vim.treesitter.create_parser(0)
-  lua require'treesitter_demo'
-  let g:has_ts = v:true
-endfunc
-
-func! TSCursor()
-  " disable matchparen
-  NoMatchParen
-  call TSTest()
-  au CursorMoved <buffer> lua ts_cursor()
-  au CursorMovedI <buffer> lua ts_cursor()
-  map <buffer> <Plug>(ts-expand) <cmd>lua ts_expand_node()<cr>
-endfunc
-
-func! TSSyntax()
-  " disable matchparen
-  set syntax=
-  call TSTest()
-  lua ts_syntax()
-endfunc
-
-command! TSTest call TSTest()
-command! TSCursor call TSCursor()
-command! TSSyntax call TSSyntax()
-- 
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')

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 3ffcb477ef1e4ae0a7183a934382ffd2c449d818 Mon Sep 17 00:00:00 2001
From: Björn Linse <bjorn.linse@gmail.com>
Date: Sat, 21 Sep 2019 10:35:49 +0200
Subject: tree-sitter: start docs

---
 runtime/doc/if_lua.txt | 106 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)

(limited to 'runtime')

diff --git a/runtime/doc/if_lua.txt b/runtime/doc/if_lua.txt
index aa2d0a03c6..0ba35aeae6 100644
--- a/runtime/doc/if_lua.txt
+++ b/runtime/doc/if_lua.txt
@@ -445,6 +445,112 @@ Example: TCP echo-server				*tcp-server*
     end)
     print('TCP echo-server listening on port: '..server:getsockname().port)
 
+------------------------------------------------------------------------------
+VIM.TREESITTER						*lua-treesitter*
+
+Nvim integrates the tree-sitter library for incremental parsing of buffers.
+
+Currently Nvim does not provide the tree-sitter parsers, instead these must
+be built separately, for instance using the tree-sitter utility.
+The parser is loaded into nvim using >
+
+    vim.treesitter.add_language("/path/to/c_parser.so", "c")
+
+<Create a parser for a buffer and a given language (if another plugin uses the
+same buffer/language combination, it will be safely reused). Use >
+
+    parser = vim.treesitter.get_parser(bufnr, lang)
+
+<`bufnr=0` can be used for current buffer. `lang` will default to 'filetype'  (this
+doesn't work yet for some filetypes like "cpp") Currently, the parser will be
+retained for the lifetime of a buffer but this is subject to change. A plugin
+should keep a reference to the parser object as long as it wants incremental
+updates.
+
+Whenever you need to access the current syntax tree, parse the buffer: >
+
+    tstree = parser:parse()
+
+<This will return an immutable tree that represents the current state of the
+buffer. When the plugin wants to access the state after a (possible) edit
+it should call `parse()` again. If the buffer wasn't edited, the same tree will
+be returned again without extra work. If the buffer was parsed before,
+incremental parsing will be done of the changed parts.
+
+NB: to use the parser directly inside a |nvim_buf_attach| lua callback, you must
+call `get_parser()` before you register your callback. But preferably parsing
+shouldn't be done directly in the change callback anyway as they will be very
+frequent. Rather a plugin that does any kind of analysis on a tree should use
+a timer to throttle too frequent updates.
+
+Tree methods						*lua-treesitter-tree*
+
+tstree:root()						*tstree:root()*
+	Return the root node of this tree.
+
+
+Node methods						*lua-treesitter-node*
+
+tsnode:parent()						*tsnode:parent()*
+	Get the node's immediate parent.
+
+tsnode:child_count()					*tsnode:child_count()*
+	Get the node's number of children.
+
+tsnode:child(N)						*tsnode:child()*
+	Get the node's child at the given index, where zero represents the
+	first child.
+
+tsnode:named_child_count()			*tsnode:named_child_count()*
+	Get the node's number of named children.
+
+tsnode:named_child(N)					*tsnode:named_child()*
+	Get the node's named child at the given index, where zero represents
+	the first named child.
+
+tsnode:start()						*tsnode:start()*
+	Get the node's start position. Return three values: the row, column
+	and total byte count (all zero-based).
+
+tsnode:end_()						*tsnode:end_()*
+	Get the node's end position. Return three values: the row, column
+	and total byte count (all zero-based).
+
+tsnode:range()						*tsnode:range()*
+	Get the range of the node. Return four values: the row, column
+	of the start position, then the row, column of the end position.
+
+tsnode:type()						*tsnode:type()*
+	Get the node's type as a string.
+
+tsnode:symbol()						*tsnode:symbol()*
+	Get the node's type as a numerical id.
+
+tsnode:named()						*tsnode:named()*
+	Check if the node is named. Named nodes correspond to named rules in
+	the  grammar, whereas anonymous nodes correspond to string literals
+	in the grammar.
+
+tsnode:missing()					*tsnode:missing()*
+	Check if the node is missing. Missing nodes are inserted by the
+	parser in order to recover from certain kinds of syntax errors.
+
+tsnode:has_error()					*tsnode:has_error()*
+	Check if the node is a syntax error or contains any syntax errors.
+
+tsnode:sexpr()						*tsnode:sexpr()*
+	Get an S-expression representing the node as a string.
+
+tsnode:descendant_for_range(start_row, start_col, end_row, end_col)
+						*tsnode:descendant_for_range()*
+	Get the smallest node within this node that spans the given range of
+	(row, column) positions
+
+tsnode:named_descendant_for_range(start_row, start_col, end_row, end_col)
+					*tsnode:named_descendant_for_range()*
+	Get the smallest named node within this node that spans the given
+	range of (row, column) positions
+
 ------------------------------------------------------------------------------
 VIM							*lua-util*
 
-- 
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')

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