Merge remote-tracking branch 'upstream/master' into mix_20240309

1 files changed, 181 insertions, 197 deletions

diff --git a/test/functional/plugin/lsp/semantic_tokens_spec.lua b/test/functional/plugin/lsp/semantic_tokens_spec.lua
index 7908c5d2e7..f72aab7e0b 100644
--- a/test/functional/plugin/lsp/semantic_tokens_spec.lua
+++ b/test/functional/plugin/lsp/semantic_tokens_spec.lua
@@ -25,7 +25,7 @@ after_each(function()
 end)
 
 describe('semantic token highlighting', function()
-  local screen
+  local screen --- @type test.functional.ui.screen
   before_each(function()
     screen = Screen.new(40, 16)
     screen:attach()
@@ -84,10 +84,8 @@ describe('semantic token highlighting', function()
 
     before_each(function()
       exec_lua(create_server_definition)
-      exec_lua(
-        [[
-        local legend, response, edit_response = ...
-        server = _create_server({
+      exec_lua(function()
+        _G.server = _G._create_server({
           capabilities = {
             semanticTokensProvider = {
               full = { delta = true },
@@ -101,24 +99,19 @@ describe('semantic token highlighting', function()
             ['textDocument/semanticTokens/full/delta'] = function(_, _, callback)
               callback(nil, vim.fn.json_decode(edit_response))
             end,
-          }
+          },
         })
-      ]],
-        legend,
-        response,
-        edit_response
-      )
+      end, legend, response, edit_response)
     end)
 
     it('buffer is highlighted when attached', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
+      insert(text)
+      exec_lua(function()
+        local bufnr = vim.api.nvim_get_current_buf()
         vim.api.nvim_win_set_buf(0, bufnr)
         vim.bo[bufnr].filetype = 'some-filetype'
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
-
-      insert(text)
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       screen:expect {
         grid = [[
@@ -141,23 +134,20 @@ describe('semantic token highlighting', function()
     end)
 
     it('use LspTokenUpdate and highlight_token', function()
-      exec_lua([[
-        vim.api.nvim_create_autocmd("LspTokenUpdate", {
+      insert(text)
+      exec_lua(function()
+        vim.api.nvim_create_autocmd('LspTokenUpdate', {
           callback = function(args)
-            local token = args.data.token
-            if token.type == "function" and token.modifiers.declaration then
-              vim.lsp.semantic_tokens.highlight_token(
-                token, args.buf, args.data.client_id, "Macro"
-              )
+            local token = args.data.token --- @type STTokenRange
+            if token.type == 'function' and token.modifiers.declaration then
+              vim.lsp.semantic_tokens.highlight_token(token, args.buf, args.data.client_id, 'Macro')
             end
           end,
         })
-        bufnr = vim.api.nvim_get_current_buf()
+        local bufnr = vim.api.nvim_get_current_buf()
         vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
-
-      insert(text)
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       screen:expect {
         grid = [[
@@ -180,18 +170,23 @@ describe('semantic token highlighting', function()
     end)
 
     it('buffer is unhighlighted when client is detached', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
-
       insert(text)
 
-      exec_lua([[
+      local bufnr = n.api.nvim_get_current_buf()
+      local client_id = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, bufnr)
+        local client_id = vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+        vim.wait(1000, function()
+          return #_G.server.messages > 1
+        end)
+        return client_id
+      end)
+
+      exec_lua(function()
+        --- @diagnostic disable-next-line:duplicate-set-field
         vim.notify = function() end
         vim.lsp.buf_detach_client(bufnr, client_id)
-      ]])
+      end)
 
       screen:expect {
         grid = [[
@@ -216,18 +211,19 @@ describe('semantic token highlighting', function()
     it(
       'buffer is highlighted and unhighlighted when semantic token highlighting is started and stopped',
       function()
-        exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
+        local bufnr = n.api.nvim_get_current_buf()
+        local client_id = exec_lua(function()
+          vim.api.nvim_win_set_buf(0, bufnr)
+          return vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+        end)
 
         insert(text)
 
-        exec_lua([[
-        vim.notify = function() end
-        vim.lsp.semantic_tokens.stop(bufnr, client_id)
-      ]])
+        exec_lua(function()
+          --- @diagnostic disable-next-line:duplicate-set-field
+          vim.notify = function() end
+          vim.lsp.semantic_tokens.stop(bufnr, client_id)
+        end)
 
         screen:expect {
           grid = [[
@@ -248,9 +244,9 @@ describe('semantic token highlighting', function()
       ]],
         }
 
-        exec_lua([[
-        vim.lsp.semantic_tokens.start(bufnr, client_id)
-      ]])
+        exec_lua(function()
+          vim.lsp.semantic_tokens.start(bufnr, client_id)
+        end)
 
         screen:expect {
           grid = [[
@@ -274,18 +270,17 @@ describe('semantic token highlighting', function()
     )
 
     it('highlights start and stop when using "0" for current buffer', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
+      local client_id = exec_lua(function()
+        return vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       insert(text)
 
-      exec_lua([[
+      exec_lua(function()
+        --- @diagnostic disable-next-line:duplicate-set-field
         vim.notify = function() end
         vim.lsp.semantic_tokens.stop(0, client_id)
-      ]])
+      end)
 
       screen:expect {
         grid = [[
@@ -306,9 +301,9 @@ describe('semantic token highlighting', function()
       ]],
       }
 
-      exec_lua([[
+      exec_lua(function()
         vim.lsp.semantic_tokens.start(0, client_id)
-      ]])
+      end)
 
       screen:expect {
         grid = [[
@@ -331,13 +326,10 @@ describe('semantic token highlighting', function()
     end)
 
     it('buffer is re-highlighted when force refreshed', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
-
       insert(text)
+      exec_lua(function()
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       screen:expect {
         grid = [[
@@ -358,9 +350,9 @@ describe('semantic token highlighting', function()
       ]],
       }
 
-      exec_lua([[
-        vim.lsp.semantic_tokens.force_refresh(bufnr)
-      ]])
+      exec_lua(function()
+        vim.lsp.semantic_tokens.force_refresh()
+      end)
 
       screen:expect {
         grid = [[
@@ -384,7 +376,9 @@ describe('semantic token highlighting', function()
 
       local messages = exec_lua('return server.messages')
       local token_request_count = 0
-      for _, message in ipairs(messages) do
+      for _, message in
+        ipairs(messages --[[@as {method:string,params:table}[] ]])
+      do
         assert(message.method ~= 'textDocument/semanticTokens/full/delta', 'delta request received')
         if message.method == 'textDocument/semanticTokens/full' then
           token_request_count = token_request_count + 1
@@ -394,31 +388,29 @@ describe('semantic token highlighting', function()
     end)
 
     it('destroys the highlighter if the buffer is deleted', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
+      exec_lua(function()
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       insert(text)
 
-      local highlighters = exec_lua([[
-        vim.api.nvim_buf_delete(bufnr, { force = true })
-        local semantic_tokens = vim.lsp.semantic_tokens
-        return semantic_tokens.__STHighlighter.active
-      ]])
-
-      eq({}, highlighters)
+      eq(
+        {},
+        exec_lua(function()
+          local bufnr = vim.api.nvim_get_current_buf()
+          vim.api.nvim_buf_delete(bufnr, { force = true })
+          return vim.lsp.semantic_tokens.__STHighlighter.active
+        end)
+      )
     end)
 
     it('updates highlights with delta request on buffer change', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
-
       insert(text)
+
+      exec_lua(function()
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
+
       screen:expect {
         grid = [[
         #include <iostream>                     |
@@ -459,45 +451,49 @@ describe('semantic token highlighting', function()
     end)
 
     it('prevents starting semantic token highlighting with invalid conditions', function()
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start_client({ name = 'dummy', cmd = server.cmd })
-        notifications = {}
-        vim.notify = function(...) table.insert(notifications, 1, {...}) end
-      ]])
-      eq(false, exec_lua('return vim.lsp.buf_is_attached(bufnr, client_id)'))
+      local client_id = exec_lua(function()
+        _G.notifications = {}
+        --- @diagnostic disable-next-line:duplicate-set-field
+        vim.notify = function(...)
+          table.insert(_G.notifications, 1, { ... })
+        end
+        return vim.lsp.start_client({ name = 'dummy', cmd = _G.server.cmd })
+      end)
+      eq(false, exec_lua('return vim.lsp.buf_is_attached(0, ...)', client_id))
 
       insert(text)
 
-      local notifications = exec_lua([[
-        vim.lsp.semantic_tokens.start(bufnr, client_id)
-        return notifications
-      ]])
-      matches('%[LSP%] Client with id %d not attached to buffer %d', notifications[1][1])
-
-      notifications = exec_lua([[
-        vim.lsp.semantic_tokens.start(bufnr, client_id + 1)
-        return notifications
-      ]])
-      matches('%[LSP%] No client with id %d', notifications[1][1])
+      matches(
+        '%[LSP%] Client with id %d not attached to buffer %d',
+        exec_lua(function()
+          vim.lsp.semantic_tokens.start(0, client_id)
+          return _G.notifications[1][1]
+        end)
+      )
+
+      matches(
+        '%[LSP%] No client with id %d',
+        exec_lua(function()
+          vim.lsp.semantic_tokens.start(0, client_id + 1)
+          return _G.notifications[1][1]
+        end)
+      )
     end)
 
     it(
       'opt-out: does not activate semantic token highlighting if disabled in client attach',
       function()
-        exec_lua([[
-          bufnr = vim.api.nvim_get_current_buf()
-          vim.api.nvim_win_set_buf(0, bufnr)
-          client_id = vim.lsp.start({
+        local client_id = exec_lua(function()
+          return vim.lsp.start({
             name = 'dummy',
-            cmd = server.cmd,
-            on_attach = vim.schedule_wrap(function(client, bufnr)
+            cmd = _G.server.cmd,
+            --- @param client vim.lsp.Client
+            on_attach = vim.schedule_wrap(function(client, _bufnr)
               client.server_capabilities.semanticTokensProvider = nil
             end),
           })
-        ]])
-        eq(true, exec_lua('return vim.lsp.buf_is_attached(bufnr, client_id)'))
+        end)
+        eq(true, exec_lua('return vim.lsp.buf_is_attached(0, ...)', client_id))
 
         insert(text)
 
@@ -520,13 +516,18 @@ describe('semantic token highlighting', function()
         ]],
         }
 
-        local notifications = exec_lua([[
-          local notifications = {}
-          vim.notify = function(...) table.insert(notifications, 1, {...}) end
-          vim.lsp.semantic_tokens.start(bufnr, client_id)
-          return notifications
-        ]])
-        eq('[LSP] Server does not support semantic tokens', notifications[1][1])
+        eq(
+          '[LSP] Server does not support semantic tokens',
+          exec_lua(function()
+            local notifications = {}
+            --- @diagnostic disable-next-line:duplicate-set-field
+            vim.notify = function(...)
+              table.insert(notifications, 1, { ... })
+            end
+            vim.lsp.semantic_tokens.start(0, client_id)
+            return notifications[1][1]
+          end)
+        )
 
         screen:expect {
           grid = [[
@@ -551,28 +552,32 @@ describe('semantic token highlighting', function()
     )
 
     it('ignores null responses from the server', function()
-      exec_lua([[
-        local legend, response, edit_response = ...
-        server2 = _create_server({
+      local client_id = exec_lua(function()
+        _G.server2 = _G._create_server({
           capabilities = {
             semanticTokensProvider = {
               full = { delta = false },
             },
           },
           handlers = {
+            --- @param callback function
             ['textDocument/semanticTokens/full'] = function(_, _, callback)
               callback(nil, nil)
             end,
-            ['textDocument/semanticTokens/full/delta'] = function()
+            --- @param callback function
+            ['textDocument/semanticTokens/full/delta'] = function(_, _, callback)
               callback(nil, nil)
             end,
-          }
+          },
         })
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server2.cmd })
-      ]])
-      eq(true, exec_lua('return vim.lsp.buf_is_attached(bufnr, client_id)'))
+        return vim.lsp.start({ name = 'dummy', cmd = _G.server2.cmd })
+      end)
+      eq(
+        true,
+        exec_lua(function()
+          return vim.lsp.buf_is_attached(0, client_id)
+        end)
+      )
 
       insert(text)
 
@@ -597,10 +602,9 @@ describe('semantic token highlighting', function()
     end)
 
     it('does not send delta requests if not supported by server', function()
-      exec_lua(
-        [[
-        local legend, response, edit_response = ...
-        server2 = _create_server({
+      insert(text)
+      exec_lua(function()
+        _G.server2 = _G._create_server({
           capabilities = {
             semanticTokensProvider = {
               full = { delta = false },
@@ -614,18 +618,11 @@ describe('semantic token highlighting', function()
             ['textDocument/semanticTokens/full/delta'] = function(_, _, callback)
               callback(nil, vim.fn.json_decode(edit_response))
             end,
-          }
+          },
         })
-        bufnr = vim.api.nvim_get_current_buf()
-        vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server2.cmd })
-      ]],
-        legend,
-        response,
-        edit_response
-      )
+        return vim.lsp.start({ name = 'dummy', cmd = _G.server2.cmd })
+      end)
 
-      insert(text)
       screen:expect {
         grid = [[
         #include <iostream>                     |
@@ -669,7 +666,9 @@ describe('semantic token highlighting', function()
       }
       local messages = exec_lua('return server2.messages')
       local token_request_count = 0
-      for _, message in ipairs(messages) do
+      for _, message in
+        ipairs(messages --[[@as {method:string,params:table}[] ]])
+      do
         assert(message.method ~= 'textDocument/semanticTokens/full/delta', 'delta request received')
         if message.method == 'textDocument/semanticTokens/full' then
           token_request_count = token_request_count + 1
@@ -1064,10 +1063,8 @@ b = "as"]],
     }) do
       it(test.it, function()
         exec_lua(create_server_definition)
-        exec_lua(
-          [[
-          local legend, resp = ...
-          server = _create_server({
+        local client_id = exec_lua(function(legend, resp)
+          _G.server = _G._create_server({
             capabilities = {
               semanticTokensProvider = {
                 full = { delta = false },
@@ -1078,25 +1075,22 @@ b = "as"]],
               ['textDocument/semanticTokens/full'] = function(_, _, callback)
                 callback(nil, vim.fn.json_decode(resp))
               end,
-            }
+            },
           })
-          bufnr = vim.api.nvim_get_current_buf()
-          vim.api.nvim_win_set_buf(0, bufnr)
-          client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-        ]],
-          test.legend,
-          test.response
-        )
+          return vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+        end, test.legend, test.response)
 
         insert(test.text)
 
         test.expected_screen()
 
-        local highlights = exec_lua([[
-          local semantic_tokens = vim.lsp.semantic_tokens
-          return semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
-        ]])
-        eq(test.expected, highlights)
+        eq(
+          test.expected,
+          exec_lua(function()
+            local bufnr = vim.api.nvim_get_current_buf()
+            return vim.lsp.semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
+          end)
+        )
       end)
     end
   end)
@@ -1449,11 +1443,11 @@ int main()
       },
     }) do
       it(test.it, function()
+        local bufnr = n.api.nvim_get_current_buf()
+        insert(test.text1)
         exec_lua(create_server_definition)
-        exec_lua(
-          [[
-          local legend, resp1, resp2 = ...
-          server = _create_server({
+        local client_id = exec_lua(function(legend, resp1, resp2)
+          _G.server = _G._create_server({
             capabilities = {
               semanticTokensProvider = {
                 full = { delta = true },
@@ -1467,54 +1461,44 @@ int main()
               ['textDocument/semanticTokens/full/delta'] = function(_, _, callback)
                 callback(nil, vim.fn.json_decode(resp2))
               end,
-            }
+            },
           })
-          bufnr = vim.api.nvim_get_current_buf()
-          vim.api.nvim_win_set_buf(0, bufnr)
-          client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
+          local client_id = assert(vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd }))
 
           -- speed up vim.api.nvim_buf_set_lines calls by changing debounce to 10 for these tests
-          semantic_tokens = vim.lsp.semantic_tokens
           vim.schedule(function()
-            semantic_tokens.stop(bufnr, client_id)
-            semantic_tokens.start(bufnr, client_id, { debounce = 10 })
+            vim.lsp.semantic_tokens.stop(bufnr, client_id)
+            vim.lsp.semantic_tokens.start(bufnr, client_id, { debounce = 10 })
           end)
-        ]],
-          test.legend,
-          test.response1,
-          test.response2
-        )
-
-        insert(test.text1)
+          return client_id
+        end, test.legend, test.response1, test.response2)
 
         test.expected_screen1()
 
-        local highlights = exec_lua([[
-          return semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
-        ]])
-
-        eq(test.expected1, highlights)
+        eq(
+          test.expected1,
+          exec_lua(function()
+            return vim.lsp.semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
+          end)
+        )
 
         if test.edit then
           feed(test.edit)
         else
-          exec_lua(
-            [[
-            local text = ...
-            vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, vim.fn.split(text, "\n"))
+          exec_lua(function(text)
+            vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, vim.fn.split(text, '\n'))
             vim.wait(15) -- wait for debounce
-          ]],
-            test.text2
-          )
+          end, test.text2)
         end
 
         test.expected_screen2()
 
-        highlights = exec_lua([[
-          return semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
-        ]])
-
-        eq(test.expected2, highlights)
+        eq(
+          test.expected2,
+          exec_lua(function()
+            return vim.lsp.semantic_tokens.__STHighlighter.active[bufnr].client_state[client_id].current_result.highlights
+          end)
+        )
       end)
     end
   end)