improved cmp panel completions

Author: zbirenbaum

lua/copilot/handlers.lua

@@ -1,14 +1,36 @@
-local oldprint = print
-local print = function (x) oldprint(vim.inspect(x)) end
-
 local lsp_handlers = {
+  callbacks = {
+    ["PanelSolution"] = {},
+    ["PanelSolutionsDone"] = {}
+  },
+}
+
+local handlers = {
   ["PanelSolution"] = function (_, result, _, config)
-    config.callback(result)
+    for _, callback in pairs(config.callbacks) do
+      callback(result)
+    end
   end,
-
-  ["PanelSolutionsDone"] = function (err, result, ctx, config)
-    config.callback()
+  ["PanelSolutionsDone"] = function (_, _, _, config)
+    for _, callback in pairs(config.callbacks) do
+      callback()
+    end
   end
 }
 
+-- require name so not confusing
+lsp_handlers.add_handler_callback = function (handler, fn_name, fn)
+  lsp_handlers.callbacks[handler][fn_name] = fn
+  vim.lsp.handlers[handler] = vim.lsp.with(handlers[handler], {
+    callbacks = lsp_handlers.callbacks[handler]
+  })
+end
+
+lsp_handlers.remove_handler_callback = function (handler, fn_name)
+  lsp_handlers.callbacks[handler][fn_name] = nil
+  vim.lsp.handlers[handler] = vim.lsp.with(handlers[handler], {
+    callbacks = lsp_handlers.callbacks[handler]
+  })
+end
+
 return lsp_handlers

lua/copilot/init.lua

@@ -7,7 +7,7 @@ local defaults = {
   plugin_manager_path = vim.fn.stdpath("data") .. "/site/pack/packer",
   server_opts_overrides = {},
   ft_disable = {},
-  cmp_method = "getCompletionsCycling"
+  cmp_method = "getPanelCompletions"
 }
 
 local config_handler = function(opts)
@@ -31,7 +31,6 @@ M.setup = function(opts)
   vim.schedule(function () client.start(user_config) end)
   if user_config.cmp_method == "getPanelCompletions" then
     local panel = require("copilot.panel").create()
-    print(vim.inspect(panel))
     require("copilot_cmp").setup(panel.complete)
   elseif user_config.cmp_method == "getCompletionsCycling" then
     require("copilot_cmp").setup()

lua/copilot/panel.lua

@@ -1,60 +1,78 @@
 local util = require("copilot.util")
+local format = require("copilot_cmp.format")
 
 local panel = {
-  n_results = 5,
   method = "getPanelCompletions",
   usecmp = false,
+  cache_line = true,
   buf = "",
   uri = "",
 }
 
-local completions = {}
+local existing_matches= {}
+
+panel.send_request = function (callback)
+  local completion_params = util.get_completion_params()
+  completion_params.panelId = panel.uri
+  callback = callback or function () end
+  vim.lsp.buf_request(0, panel.method, completion_params, callback)
+end
 
 panel.complete = vim.schedule_wrap(function (_, params, callback)
+  local context = params.context
+  existing_matches[context.bufnr] = existing_matches[context.bufnr] or {}
+  existing_matches[context.bufnr][context.cursor.row] = existing_matches[context.bufnr][context.cursor.row] or {}
+
   local add_completion = function (result)
-    local format = require("copilot_cmp.format").format_item
     if result then
       result.text = result.displayText
-      local formatted = format(params, result)
-      completions[formatted.label] = formatted
+      local formatted = format.format_item(params, result)
+      existing_matches[context.bufnr][context.cursor.row][formatted.label] = formatted
       vim.schedule(function() callback({
         isIncomplete = true,
-        items = vim.tbl_values(completions)
+        items = vim.tbl_values(existing_matches[context.bufnr][context.cursor.row])
       }) end)
     end
   end
 
   local completed = function ()
-    vim.schedule(function()
-      vim.schedule(function() callback({
-        isIncomplete = false,
-        items = vim.tbl_values(completions)
-      }) end)
-      completions = { isIncomplete = true, items = {} }
-    end)
+    vim.schedule(function() callback({
+      isIncomplete = false,
+      items = vim.tbl_values(existing_matches[context.bufnr][context.cursor.row])
+    }) end)
+    if not panel.cache_line then
+      existing_matches[context.bufnr][context.cursor.row] = {}
+    end
   end
 
-  local completion_params = util.get_completion_params(panel.method)
-  completion_params.panelId = panel.uri
-  vim.lsp.buf_request(0, panel.method, completion_params, function () end)
+  local handler = require("copilot.handlers").add_handler_callback
+  handler("PanelSolution", "cmp", add_completion)
+  handler("PanelSolutionsDone", "cmp", completed)
 
-  local handlers = require("copilot.handlers")
+  panel.send_request()
 
-  vim.lsp.handlers["PanelSolution"] = vim.lsp.with(handlers["PanelSolution"], {
-    callback = add_completion
-  })
-  vim.lsp.handlers["PanelSolutionDone"] = vim.lsp.with(handlers["PanelSolutionDone"], {
-    completed
-  })
   callback({ isIncomplete = true })
-
 end)
 
 function panel.create (opts)
   panel = vim.tbl_deep_extend("force", panel, opts or {})
   panel.buf = type(panel.uri) == "number" or vim.api.nvim_create_buf(false, true)
   vim.api.nvim_buf_set_name(panel.buf, "copilot:///" .. tostring(panel.buf))
   panel.uri = vim.uri_from_bufnr(panel.buf)
+  vim.api.nvim_create_user_command("CopilotPanel", function ()
+    local panel_suggestions = {}
+    local handlers = require("copilot.handlers")
+    handlers.add_handler_callback("PanelSolution", "print", function (result)
+      table.insert(panel_suggestions, format.clean_insertion(result.displayText))
+    end)
+    handlers.add_handler_callback("PanelSolutionsDone", "print", function ()
+      local print_buf = require("copilot.print_buf").init()
+      print_buf.print(panel_suggestions)
+      handlers.remove_handler_callback("PanelSolution", "print")
+      handlers.remove_handler_callback("PanelSolutionsDone", "print")
+    end)
+    panel.send_request()
+  end, {})
   return panel
 end
 

lua/copilot/print_buf.lua

@@ -31,6 +31,7 @@ M.clear = function ()
 end
 
 M.print = function (input)
+  vim.api.nvim_buf_set_option(M.buf, "filetype", vim.bo.filetype)
   if not cnl_valid() or not buf_valid() then M.validate()
   elseif not win_valid() then M.show() end
   if type(input) == "table" then input = vim.inspect(input) end
@@ -98,7 +99,7 @@ M.new = function ()
   a.nvim_win_set_buf(M.win, M.buf)
 end
 
-M.init = function ()
+M.init = function (opts)
   M.initialized = true
   local linked_win = a.nvim_get_current_win()
   M.print_buf =  M.exists() or M.new()