Manually provide peek location

[diego-velez]

Is there a way that I could manually provide what location to peek in?

Sometimes there are multiple options when using some LSP function (e.g. multiple options for LSP definitions), and I have my custom logic to handle that, but I want to overlook when I manually choose an option.

For example:

local function custom_handler(opts)
    -- Custom logic to handle multiple options
    local chosen_option = ...
    ...
    ...

    require('overlook.api').peek_into(chosen_option) -- Maybe something like this??
end

vim.lsp.buf.definition {on_list = custom_handler}

[WilliamHsieh]

yes it does. current implementation support adapter extension through configs. however it's limited to sync call currently. i plan to implement async adapter when vim.async module is in stable release.

overlook.nvim/lua/overlook/config.lua

Lines 135 to 142 in b859ba9

	-- Adapter-specific configurations
	adapters = {
	-- check `overlook.adapter.cursor` for implementation details
	your_custom_adapter = {
	---@return OverlookPopupOptions? @Table suitable for overlook.ui.create_popup, or nil on error.
	get = function() end,
	},
	},

for now, you can use require("overlook.ui").create_popup(opts) to provide position info to create overlook popups.

please let me know if you encounter any issue, thank you.

[diego-velez]

I implemented a proof of concept to illustrate what I mean for this issue.

I see that you're planning to implement a picker for when there are multiple LSP options. If I may, I think that the plugin should atleast provide a way specify what file to peek at. This way, user's can continue to use their preferred way of picking, and the plugin can focus on handling the peeking system.

What do you think?

[WilliamHsieh]

thank you for the POC. would you please share the workflow using this newly implemented adapter? i would like to understand it more on how you are using it.

[diego-velez]

No problem!
This might be a use case unique to me only, so I understand if you do not end up adding a feature like this.

Currently, I use mini.pick for every scenario where I need to pick between options. In case that there are multiple places given by an LSP, I have a mini.pick picker for that. Using the adapter I implemented for my fork of this plugin, I can integrate both worlds together.

Example:

    -- Open LSP picker for the given scope
    ---@param scope "declaration" | "definition" | "document_symbol" | "implementation" | "references" | "type_definition" | "workspace_symbol"
    ---@param autojump boolean? If there is only one result it will jump to it.
    function MiniPick.LspPicker(scope, autojump)
      ---@return string
      local function get_symbol_query()
        return vim.fn.input 'Symbol: '
      end

      if not autojump then
        local opts = { scope = scope }

        if scope == 'workspace_symbol' then
          opts.symbol_query = get_symbol_query()
        end

        MiniExtra.pickers.lsp(opts)
        return
      end

      ---@param opts vim.lsp.LocationOpts.OnList
      local function on_list(opts)
        MiniPick.start {
          source = {
            name = opts.title,
            items = opts.items,
            choose = function(item)
              vim.schedule(function()
                MiniPick.stop()
                require('overlook.api').peek(item)
              end)
            end,
          },
          window = {
            config = function()
              local height = math.floor(0.618 * vim.o.lines)
              local width = math.floor(0.618 * vim.o.columns)
              return {
                relative = 'cursor',
                anchor = 'NW',
                height = height,
                width = width,
                row = 0,
                col = 0,
              }
            end,
          },
        }
      end

      if scope == 'references' then
        vim.lsp.buf.references(nil, { on_list = on_list })
        return
      end

      if scope == 'workspace_symbol' then
        vim.lsp.buf.workspace_symbol(get_symbol_query(), { on_list = on_list })
        return
      end

      vim.lsp.buf[scope] { on_list = on_list }
    end