Add everything to lsp.buf and get rid of autoload.

2 files changed, 204 insertions, 45 deletions

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