added a new DynamicFinder (which can be used with rust_analyzer)

lua/telescope/builtin/init.lua

@@ -40,6 +40,7 @@ builtin.git_branches = require('telescope.builtin.git').branches
 builtin.git_status = require('telescope.builtin.git').status
 
 builtin.builtin = require('telescope.builtin.internal').builtin
+
 builtin.planets = require('telescope.builtin.internal').planets
 builtin.symbols = require('telescope.builtin.internal').symbols
 builtin.commands = require('telescope.builtin.internal').commands
@@ -70,5 +71,6 @@ builtin.lsp_document_diagnostics = require('telescope.builtin.lsp').diagnostics
 builtin.lsp_workspace_diagnostics = require('telescope.builtin.lsp').workspace_diagnostics
 builtin.lsp_range_code_actions = require('telescope.builtin.lsp').range_code_actions
 builtin.lsp_workspace_symbols = require('telescope.builtin.lsp').workspace_symbols
+builtin.lsp_dynamic_workspace_symbols = require('telescope.builtin.lsp').dynamic_workspace_symbols
 
 return builtin

lua/telescope/builtin/lsp.lua

@@ -4,6 +4,9 @@ local finders = require('telescope.finders')
 local make_entry = require('telescope.make_entry')
 local pickers = require('telescope.pickers')
 local utils = require('telescope.utils')
+local a = require('plenary.async_lib')
+local async, await = a.async, a.await
+local channel = a.util.channel
 
 local conf = require('telescope.config').values
 
@@ -218,6 +221,35 @@ lsp.workspace_symbols = function(opts)
   }):find()
 end
 
+local function get_workspace_symbols_requester(bufnr)
+  local cancel = function() end
+
+  return async(function(prompt)
+    local tx, rx = channel.oneshot()
+    cancel = vim.lsp.buf_request(bufnr, "workspace/symbol", {query = prompt}, tx)
+
+    local err, _, results_lsp = await(rx())
+    assert(not err, err)
+
+    local locations = vim.lsp.util.symbols_to_items(results_lsp, bufnr) or {}
+    return locations
+  end)
+end
+
+lsp.dynamic_workspace_symbols = function(opts)
+  local curr_bufnr = vim.api.nvim_get_current_buf()
+
+  pickers.new(opts, {
+    prompt_title = 'LSP Dynamic Workspace Symbols',
+    finder    = finders.new_live {
+      entry_maker = opts.entry_maker or make_entry.gen_from_lsp_symbols(opts),
+      fn = get_workspace_symbols_requester(curr_bufnr),
+    },
+    previewer = conf.qflist_previewer(opts),
+    sorter = conf.generic_sorter()
+  }):find()
+end
+
 lsp.diagnostics = function(opts)
   local locations = utils.diagnostics_to_tbl(opts)
 

lua/telescope/finders.lua

@@ -2,6 +2,8 @@ local Job = require('plenary.job')
 
 local make_entry = require('telescope.make_entry')
 local log = require('telescope.log')
+local a = require('plenary.async_lib')
+local await, async = a.await, a.async
 
 local async_static_finder = require('telescope.finders.async_static_finder')
 local async_oneshot_finder = require('telescope.finders.async_oneshot_finder')
@@ -20,7 +22,6 @@ local _callable_obj = function()
   return obj
 end
 
-
 --[[ =============================================================
 
     JobFinder
@@ -108,6 +109,35 @@ function JobFinder:_find(prompt, process_result, process_complete)
   self.job:start()
 end
 
+local DynamicFinder = _callable_obj()
+
+function DynamicFinder:new(opts)
+  opts = opts or {}
+
+  assert(not opts.results, "`results` should be used with finder.new_table")
+  assert(not opts.static, "`static` should be used with finder.new_oneshot_job")
+
+  local obj = setmetatable({
+    curr_buf = opts.curr_buf,
+    fn = opts.fn,
+    entry_maker = opts.entry_maker or make_entry.from_string,
+  }, self)
+
+  return obj
+end
+
+function DynamicFinder:_find(prompt, process_result, process_complete)
+  a.scope(function()
+    local results = await(self.fn(prompt))
+
+    for _, result in ipairs(results) do
+      if process_result(self.entry_maker(result)) then return end
+    end
+
+    process_complete()
+  end)
+end
+
 --- Return a new Finder
 --
 -- Use at your own risk.
@@ -185,4 +215,8 @@ finders.new_table = function(t)
   return async_static_finder(t)
 end
 
+finders.new_live = function(t)
+  return DynamicFinder:new(t)
+end
+
 return finders

lua/telescope/make_entry.lua

@@ -58,6 +58,17 @@ do
   end
 end
 
+function make_entry.gen_from_node(_)
+  return function(node)
+    local display = node.leaf or node.branch_name
+    node.display = display
+    node.ordinal = display
+    node.is_leaf = node.leaf and true or false
+
+    return node
+  end
+end
+
 do
   local lookup_keys = {
     ordinal = 1,

lua/telescope/pickers.lua

@@ -370,6 +370,7 @@ function Picker:find()
   local tx, rx = channel.mpsc()
   self.__on_lines = tx.send
 
+  local status = {}
   local main_loop = async(function()
     while true do
       await(async_lib.scheduler())
@@ -437,6 +438,8 @@ function Picker:find()
 
       self.closed = true
 
+      status.should_stop = true
+
       -- TODO: Should we actually do this?
       collectgarbage(); collectgarbage()
     end,

lua/tests/automated/tree_spec.lua

@@ -0,0 +1,118 @@
+local process = require('telescope.builtin.menu').process
+local process_root = require('telescope.builtin.menu').process_root
+
+local eq = function(a, b)
+  assert.are.same(a, b)
+end
+
+describe('preprocess function', function()
+  it('should preprocess simple', function()
+    local tree = {
+      {
+        "top level leaf",
+        "another top level leaf",
+      },
+    }
+
+    local expected = {
+      {leaf = "top level leaf", conf = {}},
+      {leaf = "another top level leaf", conf = {}},
+    }
+
+    local res = process(tree)
+    eq(expected, res)
+  end)
+
+  it('should preprocess with configuration in the root', function()
+    local tree = {
+      {
+        "top level leaf",
+        "another top level leaf",
+      },
+      title = 'test menu',
+      callback = print,
+    }
+
+    local expected = {
+      branch_name = "root",
+      branches = {
+        {leaf = "top level leaf", conf = {}},
+        {leaf = "another top level leaf", conf = {}},
+      },
+      conf = {
+        title = 'test menu',
+        callback = print,
+      }
+    }
+
+    local res = process_root(tree)
+
+    eq(expected, res)
+  end)
+
+  it('should preprocess with two levels', function()
+    local tree = {
+      {
+        "top level leaf",
+        "another top level leaf",
+        ["a node"] = {
+          {
+            "second level leaf",
+            "another second level leaf",
+          }
+        }
+      },
+    }
+
+    local expected = {
+        {leaf = "top level leaf", conf = {}},
+        {leaf = "another top level leaf", conf = {}},
+        {
+          branch_name = "a node",
+          branches = {
+            {leaf = "second level leaf", conf = {}},
+            {leaf = "another second level leaf", conf = {}},
+            {leaf = "..", conf = {}},
+          },
+          conf = {}
+        },
+    }
+
+    local res = process(tree)
+
+    eq(expected, res)
+  end)
+
+  it('should preprocess with two levels and conf', function()
+    local tree = {
+      {
+        "top level leaf",
+        "another top level leaf",
+        ["a node"] = {
+          {
+            "second level leaf",
+            "another second level leaf",
+          },
+        }
+      },
+    }
+
+    local expected = {
+      {leaf = "top level leaf", conf = {}},
+      {leaf = "another top level leaf", conf = {}},
+      {
+        branch_name = "a node",
+        branches = {
+          {leaf = "second level leaf", conf = {}},
+          {leaf = "another second level leaf", conf = {}},
+          {leaf = "..", conf = {}},
+        },
+        conf = {}
+      },
+    }
+
+    local res = process(tree)
+
+    eq(expected, res)
+  end)
+end)