test: support upvalues in exec_lua

13 files changed, 1224 insertions, 1009 deletions

diff --git a/test/functional/plugin/editorconfig_spec.lua b/test/functional/plugin/editorconfig_spec.lua
index 242ed9b57f..5f69b8938a 100644
--- a/test/functional/plugin/editorconfig_spec.lua
+++ b/test/functional/plugin/editorconfig_spec.lua
@@ -7,7 +7,6 @@ local eq = t.eq
 local pathsep = n.get_pathsep()
 local fn = n.fn
 local api = n.api
-local exec_lua = n.exec_lua
 
 local testdir = 'Xtest-editorconfig'
 
@@ -227,12 +226,12 @@ But not this one
   end)
 
   it('does not operate on invalid buffers', function()
-    local ok, err = unpack(exec_lua([[
+    local ok, err = unpack(n.exec_lua(function()
       vim.cmd.edit('test.txt')
       local bufnr = vim.api.nvim_get_current_buf()
       vim.cmd.bwipeout(bufnr)
-      return {pcall(require('editorconfig').config, bufnr)}
-    ]]))
+      return { pcall(require('editorconfig').config, bufnr) }
+    end))
 
     eq(true, ok, err)
   end)
diff --git a/test/functional/plugin/lsp/codelens_spec.lua b/test/functional/plugin/lsp/codelens_spec.lua
index cd20e95dd1..20ef1cb49e 100644
--- a/test/functional/plugin/lsp/codelens_spec.lua
+++ b/test/functional/plugin/lsp/codelens_spec.lua
@@ -13,36 +13,34 @@ describe('vim.lsp.codelens', function()
 
   it('on_codelens_stores_and_displays_lenses', function()
     local fake_uri = 'file:///fake/uri'
-    local bufnr = exec_lua(
-      [[
-      fake_uri = ...
+    local bufnr = exec_lua(function()
       local bufnr = vim.uri_to_bufnr(fake_uri)
-      local lines = {'So', 'many', 'lines'}
+      local lines = { 'So', 'many', 'lines' }
       vim.fn.bufload(bufnr)
       vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
       return bufnr
-    ]],
-      fake_uri
-    )
+    end)
 
-    exec_lua(
-      [[
-      local bufnr = ...
+    exec_lua(function()
       local lenses = {
         {
           range = {
-            start = { line = 0, character = 0, },
-            ['end'] = { line = 0, character = 0 }
+            start = { line = 0, character = 0 },
+            ['end'] = { line = 0, character = 0 },
           },
-          command = { title = 'Lens1', command = 'Dummy' }
+          command = { title = 'Lens1', command = 'Dummy' },
         },
       }
-      vim.lsp.codelens.on_codelens(nil, lenses, {method='textDocument/codeLens', client_id=1, bufnr=bufnr})
-    ]],
-      bufnr
-    )
+      vim.lsp.codelens.on_codelens(
+        nil,
+        lenses,
+        { method = 'textDocument/codeLens', client_id = 1, bufnr = bufnr }
+      )
+    end)
 
-    local stored_lenses = exec_lua('return vim.lsp.codelens.get(...)', bufnr)
+    local stored_lenses = exec_lua(function()
+      return vim.lsp.codelens.get(bufnr)
+    end)
     local expected = {
       {
         range = {
@@ -57,58 +55,54 @@ describe('vim.lsp.codelens', function()
     }
     eq(expected, stored_lenses)
 
-    local virtual_text_chunks = exec_lua(
-      [[
-      local bufnr = ...
+    local virtual_text_chunks = exec_lua(function()
       local ns = vim.lsp.codelens.__namespaces[1]
       local extmarks = vim.api.nvim_buf_get_extmarks(bufnr, ns, 0, -1, {})
       return vim.api.nvim_buf_get_extmark_by_id(bufnr, ns, extmarks[1][1], { details = true })[3].virt_text
-    ]],
-      bufnr
-    )
+    end)
 
     eq({ [1] = { 'Lens1', 'LspCodeLens' } }, virtual_text_chunks)
   end)
 
   it('can clear all lens', function()
     local fake_uri = 'file:///fake/uri'
-    local bufnr = exec_lua(
-      [[
-      fake_uri = ...
+    local bufnr = exec_lua(function()
       local bufnr = vim.uri_to_bufnr(fake_uri)
-      local lines = {'So', 'many', 'lines'}
+      local lines = { 'So', 'many', 'lines' }
       vim.fn.bufload(bufnr)
       vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
       return bufnr
-    ]],
-      fake_uri
-    )
+    end)
 
-    exec_lua(
-      [[
-      local bufnr = ...
+    exec_lua(function()
       local lenses = {
         {
           range = {
-            start = { line = 0, character = 0, },
-            ['end'] = { line = 0, character = 0 }
+            start = { line = 0, character = 0 },
+            ['end'] = { line = 0, character = 0 },
           },
-          command = { title = 'Lens1', command = 'Dummy' }
+          command = { title = 'Lens1', command = 'Dummy' },
         },
       }
-      vim.lsp.codelens.on_codelens(nil, lenses, {method='textDocument/codeLens', client_id=1, bufnr=bufnr})
-    ]],
-      bufnr
-    )
+      vim.lsp.codelens.on_codelens(
+        nil,
+        lenses,
+        { method = 'textDocument/codeLens', client_id = 1, bufnr = bufnr }
+      )
+    end)
 
-    local stored_lenses = exec_lua('return vim.lsp.codelens.get(...)', bufnr)
+    local stored_lenses = exec_lua(function()
+      return vim.lsp.codelens.get(bufnr)
+    end)
     eq(1, #stored_lenses)
 
-    exec_lua([[
+    exec_lua(function()
       vim.lsp.codelens.clear()
-    ]])
+    end)
 
-    stored_lenses = exec_lua('return vim.lsp.codelens.get(...)', bufnr)
+    stored_lenses = exec_lua(function()
+      return vim.lsp.codelens.get(bufnr)
+    end)
     eq(0, #stored_lenses)
   end)
 end)
diff --git a/test/functional/plugin/lsp/completion_spec.lua b/test/functional/plugin/lsp/completion_spec.lua
index d3796082fb..4df8d77d44 100644
--- a/test/functional/plugin/lsp/completion_spec.lua
+++ b/test/functional/plugin/lsp/completion_spec.lua
@@ -23,12 +23,10 @@ local function complete(line, candidates, lnum, server_boundary)
   -- nvim_win_get_cursor returns 0 based column, line:find returns 1 based
   local cursor_col = line:find('|') - 1
   line = line:gsub('|', '')
-  return exec_lua(
-    [[
-    local line, cursor_col, lnum, result, server_boundary = ...
+  return exec_lua(function(result)
     local line_to_cursor = line:sub(1, cursor_col)
     local client_start_boundary = vim.fn.match(line_to_cursor, '\\k*$')
-    local items, new_server_boundary = require("vim.lsp.completion")._convert_results(
+    local items, new_server_boundary = require('vim.lsp.completion')._convert_results(
       line,
       lnum,
       cursor_col,
@@ -36,19 +34,13 @@ local function complete(line, candidates, lnum, server_boundary)
       client_start_boundary,
       server_boundary,
       result,
-      "utf-16"
+      'utf-16'
     )
     return {
       items = items,
-      server_start_boundary = new_server_boundary
+      server_start_boundary = new_server_boundary,
     }
-  ]],
-    line,
-    cursor_col,
-    lnum,
-    candidates,
-    server_boundary
-  )
+  end, candidates)
 end
 
 describe('vim.lsp.completion: item conversion', function()
@@ -483,13 +475,14 @@ describe('vim.lsp.completion: protocol', function()
   before_each(function()
     clear()
     exec_lua(create_server_definition)
-    exec_lua([[
+    exec_lua(function()
       _G.capture = {}
+      --- @diagnostic disable-next-line:duplicate-set-field
       vim.fn.complete = function(col, matches)
         _G.capture.col = col
         _G.capture.matches = matches
       end
-    ]])
+    end)
   end)
 
   after_each(clear)
@@ -497,32 +490,34 @@ describe('vim.lsp.completion: protocol', function()
   --- @param completion_result lsp.CompletionList
   --- @return integer
   local function create_server(completion_result)
-    return exec_lua(
-      [[
-      local result = ...
-      local server = _create_server({
+    return exec_lua(function()
+      local server = _G._create_server({
         capabilities = {
           completionProvider = {
-            triggerCharacters = { '.' }
-          }
+            triggerCharacters = { '.' },
+          },
         },
         handlers = {
           ['textDocument/completion'] = function(_, _, callback)
-            callback(nil, result)
-          end
-        }
+            callback(nil, completion_result)
+          end,
+        },
       })
 
-      bufnr = vim.api.nvim_get_current_buf()
+      local bufnr = vim.api.nvim_get_current_buf()
       vim.api.nvim_win_set_buf(0, bufnr)
-      return vim.lsp.start({ name = 'dummy', cmd = server.cmd, on_attach = function(client, bufnr)
-        vim.lsp.completion.enable(true, client.id, bufnr, { convert = function(item)
-          return { abbr = item.label:gsub('%b()', '')}
-        end})
-      end})
-    ]],
-      completion_result
-    )
+      return vim.lsp.start({
+        name = 'dummy',
+        cmd = server.cmd,
+        on_attach = function(client, bufnr0)
+          vim.lsp.completion.enable(true, client.id, bufnr0, {
+            convert = function(item)
+              return { abbr = item.label:gsub('%b()', '') }
+            end,
+          })
+        end,
+      })
+    end)
   end
 
   local function assert_matches(fn)
@@ -533,14 +528,11 @@ describe('vim.lsp.completion: protocol', function()
 
   --- @param pos [integer, integer]
   local function trigger_at_pos(pos)
-    exec_lua(
-      [[
+    exec_lua(function()
       local win = vim.api.nvim_get_current_win()
-      vim.api.nvim_win_set_cursor(win, ...)
+      vim.api.nvim_win_set_cursor(win, pos)
       vim.lsp.completion.trigger()
-    ]],
-      pos
-    )
+    end)
 
     retry(nil, nil, function()
       neq(nil, exec_lua('return _G.capture.col'))
@@ -683,37 +675,30 @@ describe('vim.lsp.completion: protocol', function()
     }
     local client_id = create_server(completion_list)
 
-    exec_lua(
-      [[
+    exec_lua(function()
       _G.called = false
-      local client = vim.lsp.get_client_by_id(...)
-      client.commands.dummy = function ()
+      local client = assert(vim.lsp.get_client_by_id(client_id))
+      client.commands.dummy = function()
         _G.called = true
       end
-    ]],
-      client_id
-    )
+    end)
 
     feed('ih')
     trigger_at_pos({ 1, 1 })
 
-    exec_lua(
-      [[
-      local client_id, item = ...
+    local item = completion_list.items[1]
+    exec_lua(function()
       vim.v.completed_item = {
         user_data = {
           nvim = {
             lsp = {
               client_id = client_id,
-              completion_item = item
-            }
-          }
-        }
+              completion_item = item,
+            },
+          },
+        },
       }
-    ]],
-      client_id,
-      completion_list.items[1]
-    )
+    end)
 
     feed('<C-x><C-o><C-y>')
 
diff --git a/test/functional/plugin/lsp/diagnostic_spec.lua b/test/functional/plugin/lsp/diagnostic_spec.lua
index 76b1808883..78c684083b 100644
--- a/test/functional/plugin/lsp/diagnostic_spec.lua
+++ b/test/functional/plugin/lsp/diagnostic_spec.lua
@@ -11,7 +11,9 @@ local neq = t.neq
 local create_server_definition = t_lsp.create_server_definition
 
 describe('vim.lsp.diagnostic', function()
-  local fake_uri
+  local fake_uri --- @type string
+  local client_id --- @type integer
+  local diagnostic_bufnr --- @type integer
 
   before_each(function()
     clear { env = {
@@ -19,79 +21,98 @@ describe('vim.lsp.diagnostic', function()
       VIMRUNTIME = os.getenv 'VIMRUNTIME',
     } }
 
-    exec_lua [[
+    exec_lua(function()
       require('vim.lsp')
 
-      make_range = function(x1, y1, x2, y2)
+      _G.make_range = function(x1, y1, x2, y2)
         return { start = { line = x1, character = y1 }, ['end'] = { line = x2, character = y2 } }
       end
 
-      make_error = function(msg, x1, y1, x2, y2)
+      _G.make_error = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 1,
         }
       end
 
-      make_warning = function(msg, x1, y1, x2, y2)
+      _G.make_warning = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 2,
         }
       end
 
-      make_information = function(msg, x1, y1, x2, y2)
+      _G.make_information = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 3,
         }
       end
 
-      function get_extmarks(bufnr, client_id)
-        local namespace = vim.lsp.diagnostic.get_namespace(client_id)
+      function _G.get_extmarks(bufnr, client_id0)
+        local namespace = vim.lsp.diagnostic.get_namespace(client_id0)
         local ns = vim.diagnostic.get_namespace(namespace)
         local extmarks = {}
         if ns.user_data.virt_text_ns then
-          for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {details=true})) do
+          for _, e in
+            pairs(
+              vim.api.nvim_buf_get_extmarks(
+                bufnr,
+                ns.user_data.virt_text_ns,
+                0,
+                -1,
+                { details = true }
+              )
+            )
+          do
             table.insert(extmarks, e)
           end
         end
         if ns.user_data.underline_ns then
-          for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {details=true})) do
+          for _, e in
+            pairs(
+              vim.api.nvim_buf_get_extmarks(
+                bufnr,
+                ns.user_data.underline_ns,
+                0,
+                -1,
+                { details = true }
+              )
+            )
+          do
             table.insert(extmarks, e)
           end
         end
         return extmarks
       end
 
-      client_id = vim.lsp.start_client {
+      client_id = assert(vim.lsp.start_client {
         cmd_env = {
-          NVIM_LUA_NOTRACK = "1";
-        };
+          NVIM_LUA_NOTRACK = '1',
+        },
         cmd = {
-          vim.v.progpath, '-es', '-u', 'NONE', '--headless'
-        };
-        offset_encoding = "utf-16";
-      }
-    ]]
+          vim.v.progpath,
+          '-es',
+          '-u',
+          'NONE',
+          '--headless',
+        },
+        offset_encoding = 'utf-16',
+      })
+    end)
 
     fake_uri = 'file:///fake/uri'
 
-    exec_lua(
-      [[
-      fake_uri = ...
+    exec_lua(function()
       diagnostic_bufnr = vim.uri_to_bufnr(fake_uri)
-      local lines = {"1st line of text", "2nd line of text", "wow", "cool", "more", "lines"}
+      local lines = { '1st line of text', '2nd line of text', 'wow', 'cool', 'more', 'lines' }
       vim.fn.bufload(diagnostic_bufnr)
       vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, 1, false, lines)
       vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-      return diagnostic_bufnr
-    ]],
-      fake_uri
-    )
+    end)
   end)
 
   after_each(function()
@@ -101,89 +122,73 @@ describe('vim.lsp.diagnostic', function()
   describe('vim.lsp.diagnostic.on_publish_diagnostics', function()
     it('allows configuring the virtual text via vim.lsp.with', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+      local extmarks = exec_lua(function()
+        _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
           virtual_text = {
-            spacing = ...,
+            spacing = expected_spacing,
           },
         })
 
-        PublishDiagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('Delayed Diagnostic', 4, 4, 4, 4),
-            }
-          }, {client_id=client_id}
-        )
+        _G.PublishDiagnostics(nil, {
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
+          },
+        }, { client_id = client_id })
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
 
-      local virt_text = extmarks[1][4].virt_text
-      local spacing = virt_text[1][1]
+      local spacing = extmarks[1][4].virt_text[1][1]
 
       eq(expected_spacing, #spacing)
     end)
 
     it('allows configuring the virtual text via vim.lsp.with using a function', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        spacing = ...
-
-        PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+      local extmarks = exec_lua(function()
+        _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
           virtual_text = function()
             return {
-              spacing = spacing,
+              spacing = expected_spacing,
             }
           end,
         })
 
-        PublishDiagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('Delayed Diagnostic', 4, 4, 4, 4),
-            }
-          }, {client_id=client_id}
-        )
+        _G.PublishDiagnostics(nil, {
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
+          },
+        }, { client_id = client_id })
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
 
-      local virt_text = extmarks[1][4].virt_text
-      local spacing = virt_text[1][1]
+      local spacing = extmarks[1][4].virt_text[1][1]
 
       eq(expected_spacing, #spacing)
     end)
 
     it('allows filtering via severity limit', function()
       local get_extmark_count_with_severity = function(severity_limit)
-        return exec_lua(
-          [[
-          PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+        return exec_lua(function()
+          _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
             underline = false,
             virtual_text = {
-              severity = { min = ... }
+              severity = { min = severity_limit },
             },
           })
 
-          PublishDiagnostics(nil, {
-              uri = fake_uri,
-              diagnostics = {
-                make_warning('Delayed Diagnostic', 4, 4, 4, 4),
-              }
-            }, {client_id=client_id}
-          )
-
-          return #get_extmarks(diagnostic_bufnr, client_id)
-        ]],
-          severity_limit
-        )
+          _G.PublishDiagnostics(nil, {
+            uri = fake_uri,
+            diagnostics = {
+              _G.make_warning('Delayed Diagnostic', 4, 4, 4, 4),
+            },
+          }, { client_id = client_id })
+
+          return #_G.get_extmarks(diagnostic_bufnr, client_id)
+        end, client_id, fake_uri, severity_limit)
       end
 
       -- No messages with Error or higher
@@ -196,246 +201,284 @@ describe('vim.lsp.diagnostic', function()
 
     it('correctly handles UTF-16 offsets', function()
       local line = 'All 💼 and no 🎉 makes Jack a dull 👦'
-      local result = exec_lua(
-        [[
-        local line = ...
-        vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, -1, false, {line})
+      local result = exec_lua(function()
+        vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, -1, false, { line })
 
         vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('UTF-16 Diagnostic', 0, 7, 0, 8),
-            }
-          }, {client_id=client_id}
-        )
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('UTF-16 Diagnostic', 0, 7, 0, 8),
+          },
+        }, { client_id = client_id })
 
         local diags = vim.diagnostic.get(diagnostic_bufnr)
         vim.lsp.stop_client(client_id)
         vim.api.nvim_exec_autocmds('VimLeavePre', { modeline = false })
         return diags
-      ]],
-        line
-      )
+      end)
       eq(1, #result)
-      eq(exec_lua([[return vim.str_byteindex(..., 7, true)]], line), result[1].col)
-      eq(exec_lua([[return vim.str_byteindex(..., 8, true)]], line), result[1].end_col)
+      eq(
+        exec_lua(function()
+          return vim.str_byteindex(line, 7, true)
+        end),
+        result[1].col
+      )
+      eq(
+        exec_lua(function()
+          return vim.str_byteindex(line, 8, true)
+        end),
+        result[1].end_col
+      )
     end)
 
     it('does not create buffer on empty diagnostics', function()
-      local bufnr
-
       -- No buffer is created without diagnostics
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {},
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      eq(-1, bufnr)
+      eq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {},
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
 
       -- Create buffer on diagnostics
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {
-            make_error('Diagnostic', 0, 0, 0, 0),
-          },
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      neq(-1, bufnr)
-      eq(1, exec_lua([[return #vim.diagnostic.get(...)]], bufnr))
+      neq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {
+              _G.make_error('Diagnostic', 0, 0, 0, 0),
+            },
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(_G.bufnr)
+        end)
+      )
 
       -- Clear diagnostics after buffer was created
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {},
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      neq(-1, bufnr)
-      eq(0, exec_lua([[return #vim.diagnostic.get(...)]], bufnr))
+      neq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {},
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
+      eq(
+        0,
+        exec_lua(function()
+          return #vim.diagnostic.get(_G.bufnr)
+        end)
+      )
     end)
   end)
 
   describe('vim.lsp.diagnostic.on_diagnostic', function()
     before_each(function()
       exec_lua(create_server_definition)
-      exec_lua([[
-        server = _create_server({
+      exec_lua(function()
+        _G.server = _G._create_server({
           capabilities = {
-            diagnosticProvider = {
-            }
-          }
+            diagnosticProvider = {},
+          },
         })
 
-        function get_extmarks(bufnr, client_id)
-          local namespace = vim.lsp.diagnostic.get_namespace(client_id, true)
+        function _G.get_extmarks(bufnr, client_id0)
+          local namespace = vim.lsp.diagnostic.get_namespace(client_id0, true)
           local ns = vim.diagnostic.get_namespace(namespace)
           local extmarks = {}
           if ns.user_data.virt_text_ns then
-            for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {details=true})) do
+            for _, e in
+              pairs(
+                vim.api.nvim_buf_get_extmarks(
+                  bufnr,
+                  ns.user_data.virt_text_ns,
+                  0,
+                  -1,
+                  { details = true }
+                )
+              )
+            do
               table.insert(extmarks, e)
             end
           end
           if ns.user_data.underline_ns then
-            for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {details=true})) do
+            for _, e in
+              pairs(
+                vim.api.nvim_buf_get_extmarks(
+                  bufnr,
+                  ns.user_data.underline_ns,
+                  0,
+                  -1,
+                  { details = true }
+                )
+              )
+            do
               table.insert(extmarks, e)
             end
           end
           return extmarks
         end
 
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
+        client_id = vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
     end)
 
     it('adds diagnostics to vim.diagnostics', function()
-      local diags = exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      local diags = exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
 
         return vim.diagnostic.get(diagnostic_bufnr)
-      ]])
+      end)
       eq(1, #diags)
       eq('Pull Diagnostic', diags[1].message)
     end)
 
     it('severity defaults to error if missing', function()
       ---@type vim.Diagnostic[]
-      local diagnostics = exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              {
-                range = make_range(4, 4, 4, 4),
-                message = "bad!",
-              }
-            }
-          },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
+      local diagnostics = exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            {
+              range = _G.make_range(4, 4, 4, 4),
+              message = 'bad!',
             },
-            uri = fake_uri,
-            client_id = client_id,
           },
-          {}
-        )
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
+          },
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
         return vim.diagnostic.get(diagnostic_bufnr)
-      ]])
+      end)
       eq(1, #diagnostics)
       eq(1, diagnostics[1].severity)
     end)
 
     it('allows configuring the virtual text via vim.lsp.with', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        Diagnostic = vim.lsp.with(vim.lsp.diagnostic.on_diagnostic, {
+      local extmarks = exec_lua(function()
+        _G.Diagnostic = vim.lsp.with(vim.lsp.diagnostic.on_diagnostic, {
           virtual_text = {
-            spacing = ...,
+            spacing = expected_spacing,
           },
         })
 
-        Diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+        _G.Diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
       eq(2, #extmarks)
       eq(expected_spacing, #extmarks[1][4].virt_text[1][1])
     end)
 
     it('clears diagnostics when client detaches', function()
-      exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
-      ]])
-      local diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
+      end)
+
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
 
-      exec_lua([[ vim.lsp.stop_client(client_id) ]])
+      exec_lua(function()
+        vim.lsp.stop_client(client_id)
+      end)
 
-      diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(0, #diags)
+      eq(
+        0,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
     end)
 
     it('keeps diagnostics when one client detaches and others still are attached', function()
-      exec_lua([[
-        client_id2 = vim.lsp.start({ name = 'dummy2', cmd = server.cmd })
-
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      local client_id2
+      exec_lua(function()
+        client_id2 = vim.lsp.start({ name = 'dummy2', cmd = _G.server.cmd })
+
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
-      ]])
-      local diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
+      end)
+
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
 
-      exec_lua([[ vim.lsp.stop_client(client_id2) ]])
+      exec_lua(function()
+        vim.lsp.stop_client(client_id2)
+      end)
 
-      diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
     end)
   end)
 end)
diff --git a/test/functional/plugin/lsp/handler_spec.lua b/test/functional/plugin/lsp/handler_spec.lua
index 013a5fb5e7..4b05b676a8 100644
--- a/test/functional/plugin/lsp/handler_spec.lua
+++ b/test/functional/plugin/lsp/handler_spec.lua
@@ -11,28 +11,31 @@ describe('lsp-handlers', function()
     it('should return a table with the default keys', function()
       eq(
         { hello = 'world' },
-        exec_lua [[
-        return vim.lsp._with_extend('test', { hello = 'world' })
-      ]]
+        exec_lua(function()
+          return vim.lsp._with_extend('test', { hello = 'world' })
+        end)
       )
     end)
 
     it('should override with config keys', function()
       eq(
         { hello = 'universe', other = true },
-        exec_lua [[
-        return vim.lsp._with_extend('test', { other = true, hello = 'world' }, { hello = 'universe' })
-      ]]
+        exec_lua(function()
+          return vim.lsp._with_extend(
+            'test',
+            { other = true, hello = 'world' },
+            { hello = 'universe' }
+          )
+        end)
       )
     end)
 
     it('should not allow invalid keys', function()
       matches(
         '.*Invalid option for `test`.*',
-        pcall_err(
-          exec_lua,
-          "return vim.lsp._with_extend('test', { hello = 'world' }, { invalid = true })"
-        )
+        pcall_err(exec_lua, function()
+          return vim.lsp._with_extend('test', { hello = 'world' }, { invalid = true })
+        end)
       )
     end)
   end)
diff --git a/test/functional/plugin/lsp/incremental_sync_spec.lua b/test/functional/plugin/lsp/incremental_sync_spec.lua
index 1e463d5117..f60e159d64 100644
--- a/test/functional/plugin/lsp/incremental_sync_spec.lua
+++ b/test/functional/plugin/lsp/incremental_sync_spec.lua
@@ -10,11 +10,9 @@ local feed = n.feed
 
 before_each(function()
   clear()
-  exec_lua [[
-    local evname = ...
+  exec_lua(function()
     local sync = require('vim.lsp.sync')
     local events = {}
-    local buffer_cache = {}
 
     -- local format_line_ending = {
     --   ["unix"] = '\n',
@@ -24,35 +22,43 @@ before_each(function()
 
     -- local line_ending = format_line_ending[vim.api.nvim_get_option_value('fileformat', {})]
 
-
-    function test_register(bufnr, id, offset_encoding, line_ending)
-      local curr_lines
+    --- @diagnostic disable-next-line:duplicate-set-field
+    function _G.test_register(bufnr, id, offset_encoding, line_ending)
       local prev_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)
 
-      local function callback(_, bufnr, changedtick, firstline, lastline, new_lastline)
-        if test_unreg == id then
+      local function callback(_, bufnr0, _changedtick, firstline, lastline, new_lastline)
+        if _G.test_unreg == id then
           return true
         end
 
-        local curr_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)
+        local curr_lines = vim.api.nvim_buf_get_lines(bufnr0, 0, -1, true)
         local incremental_change = sync.compute_diff(
-          prev_lines, curr_lines, firstline, lastline, new_lastline, offset_encoding, line_ending)
+          prev_lines,
+          curr_lines,
+          firstline,
+          lastline,
+          new_lastline,
+          offset_encoding,
+          line_ending
+        )
 
         table.insert(events, incremental_change)
         prev_lines = curr_lines
       end
-      local opts = {on_lines=callback, on_detach=callback, on_reload=callback}
+      local opts = { on_lines = callback, on_detach = callback, on_reload = callback }
       vim.api.nvim_buf_attach(bufnr, false, opts)
     end
 
-    function get_events()
+    --- @diagnostic disable-next-line:duplicate-set-field
+    function _G.get_events()
       local ret_events = events
       events = {}
       return ret_events
     end
-  ]]
+  end)
 end)
 
+--- @param edit_operations string[]
 local function test_edit(
   prev_buffer,
   edit_operations,
@@ -64,13 +70,22 @@ local function test_edit(
   line_ending = line_ending or '\n'
 
   api.nvim_buf_set_lines(0, 0, -1, true, prev_buffer)
-  exec_lua('return test_register(...)', 0, 'test1', offset_encoding, line_ending)
+  exec_lua(function()
+    return _G.test_register(0, 'test1', offset_encoding, line_ending)
+  end)
 
   for _, edit in ipairs(edit_operations) do
     feed(edit)
   end
-  eq(expected_text_changes, exec_lua('return get_events(...)'))
-  exec_lua("test_unreg = 'test1'")
+  eq(
+    expected_text_changes,
+    exec_lua(function()
+      return _G.get_events()
+    end)
+  )
+  exec_lua(function()
+    _G.test_unreg = 'test1'
+  end)
 end
 
 describe('incremental synchronization', function()
diff --git a/test/functional/plugin/lsp/inlay_hint_spec.lua b/test/functional/plugin/lsp/inlay_hint_spec.lua
index 00f79b9963..471f2cc3e8 100644
--- a/test/functional/plugin/lsp/inlay_hint_spec.lua
+++ b/test/functional/plugin/lsp/inlay_hint_spec.lua
@@ -57,36 +57,39 @@ int main() {
 
   --- @type test.functional.ui.screen
   local screen
+
+  --- @type integer
+  local client_id
+
+  --- @type integer
+  local bufnr
+
   before_each(function()
     clear_notrace()
     screen = Screen.new(50, 9)
     screen:attach()
 
+    bufnr = n.api.nvim_get_current_buf()
     exec_lua(create_server_definition)
-    exec_lua(
-      [[
-    local response = ...
-    server = _create_server({
-      capabilities = {
-        inlayHintProvider = true,
-      },
-      handlers = {
-        ['textDocument/inlayHint'] = function(_, _, callback)
-          callback(nil, vim.json.decode(response))
-        end,
-      }
-    })
-
-    bufnr = vim.api.nvim_get_current_buf()
-    vim.api.nvim_win_set_buf(0, bufnr)
+    client_id = exec_lua(function()
+      _G.server = _G._create_server({
+        capabilities = {
+          inlayHintProvider = true,
+        },
+        handlers = {
+          ['textDocument/inlayHint'] = function(_, _, callback)
+            callback(nil, vim.json.decode(response))
+          end,
+        },
+      })
 
-    client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-  ]],
-      response
-    )
+      return vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+    end)
 
     insert(text)
-    exec_lua([[vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })]])
+    exec_lua(function()
+      vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
+    end)
     screen:expect({ grid = grid_with_inlay_hints })
   end)
 
@@ -95,13 +98,15 @@ int main() {
   end)
 
   it('clears inlay hints when sole client detaches', function()
-    exec_lua([[vim.lsp.stop_client(client_id)]])
+    exec_lua(function()
+      vim.lsp.stop_client(client_id)
+    end)
     screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
   end)
 
   it('does not clear inlay hints when one of several clients detaches', function()
-    exec_lua([[
-      server2 = _create_server({
+    local client_id2 = exec_lua(function()
+      _G.server2 = _G._create_server({
         capabilities = {
           inlayHintProvider = true,
         },
@@ -109,13 +114,16 @@ int main() {
           ['textDocument/inlayHint'] = function(_, _, callback)
             callback(nil, {})
           end,
-        }
+        },
       })
-      client2 = vim.lsp.start({ name = 'dummy2', cmd = server2.cmd })
+      local client_id2 = vim.lsp.start({ name = 'dummy2', cmd = _G.server2.cmd })
       vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
-    ]])
+      return client_id2
+    end)
 
-    exec_lua([[ vim.lsp.stop_client(client2) ]])
+    exec_lua(function()
+      vim.lsp.stop_client(client_id2)
+    end)
     screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
   end)
 
@@ -123,61 +131,85 @@ int main() {
     it('validation', function()
       t.matches(
         'enable: expected boolean, got table',
-        t.pcall_err(exec_lua, [[vim.lsp.inlay_hint.enable({}, { bufnr = bufnr })]])
+        t.pcall_err(exec_lua, function()
+          --- @diagnostic disable-next-line:param-type-mismatch
+          vim.lsp.inlay_hint.enable({}, { bufnr = bufnr })
+        end)
       )
       t.matches(
         'enable: expected boolean, got number',
-        t.pcall_err(exec_lua, [[vim.lsp.inlay_hint.enable(42)]])
+        t.pcall_err(exec_lua, function()
+          --- @diagnostic disable-next-line:param-type-mismatch
+          vim.lsp.inlay_hint.enable(42)
+        end)
       )
       t.matches(
         'filter: expected table, got number',
-        t.pcall_err(exec_lua, [[vim.lsp.inlay_hint.enable(true, 42)]])
+        t.pcall_err(exec_lua, function()
+          --- @diagnostic disable-next-line:param-type-mismatch
+          vim.lsp.inlay_hint.enable(true, 42)
+        end)
       )
     end)
 
     describe('clears/applies inlay hints when passed false/true/nil', function()
+      local bufnr2 --- @type integer
       before_each(function()
-        exec_lua([[
-          bufnr2 = vim.api.nvim_create_buf(true, false)
-          vim.lsp.buf_attach_client(bufnr2, client_id)
-          vim.api.nvim_win_set_buf(0, bufnr2)
-        ]])
+        bufnr2 = exec_lua(function()
+          local bufnr2_0 = vim.api.nvim_create_buf(true, false)
+          vim.lsp.buf_attach_client(bufnr2_0, client_id)
+          vim.api.nvim_win_set_buf(0, bufnr2_0)
+          return bufnr2_0
+        end)
         insert(text)
-        exec_lua([[vim.lsp.inlay_hint.enable(true, { bufnr = bufnr2 })]])
-        exec_lua([[vim.api.nvim_win_set_buf(0, bufnr)]])
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(true, { bufnr = bufnr2 })
+        end)
+        n.api.nvim_win_set_buf(0, bufnr)
         screen:expect({ grid = grid_with_inlay_hints })
       end)
 
       it('for one single buffer', function()
-        exec_lua([[
+        exec_lua(function()
           vim.lsp.inlay_hint.enable(false, { bufnr = bufnr })
           vim.api.nvim_win_set_buf(0, bufnr2)
-        ]])
+        end)
         screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
-        exec_lua([[vim.api.nvim_win_set_buf(0, bufnr)]])
+        n.api.nvim_win_set_buf(0, bufnr)
         screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
 
-        exec_lua([[vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })]])
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
+        end)
         screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
 
-        exec_lua(
-          [[vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }), { bufnr = bufnr })]]
-        )
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(
+            not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }),
+            { bufnr = bufnr }
+          )
+        end)
         screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
 
-        exec_lua([[vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })]])
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
+        end)
         screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
       end)
 
       it('for all buffers', function()
-        exec_lua([[vim.lsp.inlay_hint.enable(false)]])
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(false)
+        end)
         screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
-        exec_lua([[vim.api.nvim_win_set_buf(0, bufnr2)]])
+        n.api.nvim_win_set_buf(0, bufnr2)
         screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
 
-        exec_lua([[vim.lsp.inlay_hint.enable(true)]])
+        exec_lua(function()
+          vim.lsp.inlay_hint.enable(true)
+        end)
         screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
-        exec_lua([[vim.api.nvim_win_set_buf(0, bufnr)]])
+        n.api.nvim_win_set_buf(0, bufnr)
         screen:expect({ grid = grid_with_inlay_hints, unchanged = true })
       end)
     end)
@@ -198,10 +230,8 @@ int main() {
         paddingRight = false,
       }
 
-      exec_lua(
-        [[
-        local expected2 = ...
-        server2 = _create_server({
+      exec_lua(function()
+        _G.server2 = _G._create_server({
           capabilities = {
             inlayHintProvider = true,
           },
@@ -209,52 +239,63 @@ int main() {
             ['textDocument/inlayHint'] = function(_, _, callback)
               callback(nil, { expected2 })
             end,
-          }
+          },
         })
-        client2 = vim.lsp.start({ name = 'dummy2', cmd = server2.cmd })
+        _G.client2 = vim.lsp.start({ name = 'dummy2', cmd = _G.server2.cmd })
         vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
-      ]],
-        expected2
-      )
+      end)
 
       --- @type vim.lsp.inlay_hint.get.ret
-      local res = exec_lua([[return vim.lsp.inlay_hint.get()]])
-      eq({
-        { bufnr = 1, client_id = 1, inlay_hint = expected[1] },
-        { bufnr = 1, client_id = 1, inlay_hint = expected[2] },
-        { bufnr = 1, client_id = 1, inlay_hint = expected[3] },
-        { bufnr = 1, client_id = 2, inlay_hint = expected2 },
-      }, res)
+      eq(
+        {
+          { bufnr = 1, client_id = 1, inlay_hint = expected[1] },
+          { bufnr = 1, client_id = 1, inlay_hint = expected[2] },
+          { bufnr = 1, client_id = 1, inlay_hint = expected[3] },
+          { bufnr = 1, client_id = 2, inlay_hint = expected2 },
+        },
+        exec_lua(function()
+          return vim.lsp.inlay_hint.get()
+        end)
+      )
 
-      --- @type vim.lsp.inlay_hint.get.ret
-      res = exec_lua([[return vim.lsp.inlay_hint.get({
-        range = {
-          start = { line = 2, character = 10 },
-          ["end"] = { line = 2, character = 10 },
+      eq(
+        {
+          { bufnr = 1, client_id = 2, inlay_hint = expected2 },
         },
-      })]])
-      eq({
-        { bufnr = 1, client_id = 2, inlay_hint = expected2 },
-      }, res)
+        exec_lua(function()
+          return vim.lsp.inlay_hint.get({
+            range = {
+              start = { line = 2, character = 10 },
+              ['end'] = { line = 2, character = 10 },
+            },
+          })
+        end)
+      )
 
-      --- @type vim.lsp.inlay_hint.get.ret
-      res = exec_lua([[return vim.lsp.inlay_hint.get({
-        bufnr = vim.api.nvim_get_current_buf(),
-        range = {
-          start = { line = 4, character = 18 },
-          ["end"] = { line = 5, character = 17 },
+      eq(
+        {
+          { bufnr = 1, client_id = 1, inlay_hint = expected[2] },
+          { bufnr = 1, client_id = 1, inlay_hint = expected[3] },
         },
-      })]])
-      eq({
-        { bufnr = 1, client_id = 1, inlay_hint = expected[2] },
-        { bufnr = 1, client_id = 1, inlay_hint = expected[3] },
-      }, res)
+        exec_lua(function()
+          return vim.lsp.inlay_hint.get({
+            bufnr = vim.api.nvim_get_current_buf(),
+            range = {
+              start = { line = 4, character = 18 },
+              ['end'] = { line = 5, character = 17 },
+            },
+          })
+        end)
+      )
 
-      --- @type vim.lsp.inlay_hint.get.ret
-      res = exec_lua([[return vim.lsp.inlay_hint.get({
-        bufnr = vim.api.nvim_get_current_buf() + 1,
-      })]])
-      eq({}, res)
+      eq(
+        {},
+        exec_lua(function()
+          return vim.lsp.inlay_hint.get({
+            bufnr = vim.api.nvim_get_current_buf() + 1,
+          })
+        end)
+      )
     end)
   end)
 end)
@@ -288,40 +329,45 @@ test text
 
   --- @type test.functional.ui.screen
   local screen
+
+  --- @type integer
+  local client_id
+
+  --- @type integer
+  local bufnr
+
   before_each(function()
     clear_notrace()
     screen = Screen.new(50, 3)
     screen:attach()
 
     exec_lua(create_server_definition)
-    exec_lua(
-      [[
-    local response = ...
-    server = _create_server({
-      capabilities = {
-        inlayHintProvider = true,
-      },
-      handlers = {
-        ['textDocument/inlayHint'] = function(_, _, callback)
-          callback(nil, vim.json.decode(response))
-        end,
-      }
-    })
+    bufnr = n.api.nvim_get_current_buf()
+    client_id = exec_lua(function()
+      _G.server = _G._create_server({
+        capabilities = {
+          inlayHintProvider = true,
+        },
+        handlers = {
+          ['textDocument/inlayHint'] = function(_, _, callback)
+            callback(nil, vim.json.decode(response))
+          end,
+        },
+      })
 
-    bufnr = vim.api.nvim_get_current_buf()
-    vim.api.nvim_win_set_buf(0, bufnr)
+      vim.api.nvim_win_set_buf(0, bufnr)
 
-    client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-  ]],
-      response
-    )
+      return vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+    end)
     insert(text)
   end)
 
   it('renders hints with same position in received order', function()
     exec_lua([[vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })]])
     screen:expect({ grid = grid_with_inlay_hints })
-    exec_lua([[vim.lsp.stop_client(client_id)]])
+    exec_lua(function()
+      vim.lsp.stop_client(client_id)
+    end)
     screen:expect({ grid = grid_without_inlay_hints, unchanged = true })
   end)
 
diff --git a/test/functional/plugin/lsp/semantic_tokens_spec.lua b/test/functional/plugin/lsp/semantic_tokens_spec.lua
index 9babb080e7..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,23 +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()
       insert(text)
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
+      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 })
-      ]])
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       screen:expect {
         grid = [[
@@ -141,21 +135,19 @@ describe('semantic token highlighting', function()
 
     it('use LspTokenUpdate and highlight_token', function()
       insert(text)
-      exec_lua([[
-        vim.api.nvim_create_autocmd("LspTokenUpdate", {
+      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 })
-      ]])
+        vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
 
       screen:expect {
         grid = [[
@@ -180,19 +172,21 @@ describe('semantic token highlighting', function()
     it('buffer is unhighlighted when client is detached', function()
       insert(text)
 
-      exec_lua([[
-        bufnr = vim.api.nvim_get_current_buf()
+      local bufnr = n.api.nvim_get_current_buf()
+      local client_id = exec_lua(function()
         vim.api.nvim_win_set_buf(0, bufnr)
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
+        local client_id = vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
         vim.wait(1000, function()
-          return #server.messages > 1
+          return #_G.server.messages > 1
         end)
-      ]])
+        return client_id
+      end)
 
-      exec_lua([[
+      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 = [[
@@ -217,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 = [[
@@ -249,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 = [[
@@ -275,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 = [[
@@ -307,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 = [[
@@ -333,11 +327,9 @@ describe('semantic token highlighting', function()
 
     it('buffer is re-highlighted when force refreshed', function()
       insert(text)
-      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)
 
       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,28 @@ 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()
       insert(text)
 
-      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)
 
       screen:expect {
         grid = [[
@@ -460,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)
 
@@ -521,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 = [[
@@ -552,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)
 
@@ -599,10 +603,8 @@ describe('semantic token highlighting', function()
 
     it('does not send delta requests if not supported by server', function()
       insert(text)
-      exec_lua(
-        [[
-        local legend, response, edit_response = ...
-        server2 = _create_server({
+      exec_lua(function()
+        _G.server2 = _G._create_server({
           capabilities = {
             semanticTokensProvider = {
               full = { delta = false },
@@ -616,16 +618,10 @@ 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)
 
       screen:expect {
         grid = [[
@@ -670,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
@@ -1065,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 },
@@ -1079,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)
@@ -1450,12 +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 },
@@ -1469,52 +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
-        )
+          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)
diff --git a/test/functional/plugin/lsp/testutil.lua b/test/functional/plugin/lsp/testutil.lua
index f60d111f87..a36cbac568 100644
--- a/test/functional/plugin/lsp/testutil.lua
+++ b/test/functional/plugin/lsp/testutil.lua
@@ -108,61 +108,55 @@ M.fake_lsp_code = 'test/functional/fixtures/fake-lsp-server.lua'
 M.fake_lsp_logfile = 'Xtest-fake-lsp.log'
 
 local function fake_lsp_server_setup(test_name, timeout_ms, options, settings)
-  exec_lua(
-    function(test_name0, fake_lsp_code0, fake_lsp_logfile0, timeout, options0, settings0)
-      _G.lsp = require('vim.lsp')
-      _G.TEST_RPC_CLIENT_ID = _G.lsp.start_client {
-        cmd_env = {
-          NVIM_LOG_FILE = fake_lsp_logfile0,
-          NVIM_LUA_NOTRACK = '1',
-          NVIM_APPNAME = 'nvim_lsp_test',
-        },
-        cmd = {
-          vim.v.progpath,
-          '-l',
-          fake_lsp_code0,
-          test_name0,
-          tostring(timeout),
-        },
-        handlers = setmetatable({}, {
-          __index = function(_t, _method)
-            return function(...)
-              return vim.rpcrequest(1, 'handler', ...)
-            end
-          end,
-        }),
-        workspace_folders = {
-          {
-            uri = 'file://' .. vim.uv.cwd(),
-            name = 'test_folder',
-          },
-        },
-        before_init = function(_params, _config)
-          vim.schedule(function()
-            vim.rpcrequest(1, 'setup')
-          end)
-        end,
-        on_init = function(client, result)
-          _G.TEST_RPC_CLIENT = client
-          vim.rpcrequest(1, 'init', result)
+  exec_lua(function(fake_lsp_code, fake_lsp_logfile, timeout)
+    options = options or {}
+    settings = settings or {}
+    _G.lsp = require('vim.lsp')
+    _G.TEST_RPC_CLIENT_ID = _G.lsp.start_client {
+      cmd_env = {
+        NVIM_LOG_FILE = fake_lsp_logfile,
+        NVIM_LUA_NOTRACK = '1',
+        NVIM_APPNAME = 'nvim_lsp_test',
+      },
+      cmd = {
+        vim.v.progpath,
+        '-l',
+        fake_lsp_code,
+        test_name,
+        tostring(timeout),
+      },
+      handlers = setmetatable({}, {
+        __index = function(_t, _method)
+          return function(...)
+            return vim.rpcrequest(1, 'handler', ...)
+          end
         end,
-        flags = {
-          allow_incremental_sync = options0.allow_incremental_sync or false,
-          debounce_text_changes = options0.debounce_text_changes or 0,
+      }),
+      workspace_folders = {
+        {
+          uri = 'file://' .. vim.uv.cwd(),
+          name = 'test_folder',
         },
-        settings = settings0,
-        on_exit = function(...)
-          vim.rpcnotify(1, 'exit', ...)
-        end,
-      }
-    end,
-    test_name,
-    M.fake_lsp_code,
-    M.fake_lsp_logfile,
-    timeout_ms or 1e3,
-    options or {},
-    settings or {}
-  )
+      },
+      before_init = function(_params, _config)
+        vim.schedule(function()
+          vim.rpcrequest(1, 'setup')
+        end)
+      end,
+      on_init = function(client, result)
+        _G.TEST_RPC_CLIENT = client
+        vim.rpcrequest(1, 'init', result)
+      end,
+      flags = {
+        allow_incremental_sync = options.allow_incremental_sync or false,
+        debounce_text_changes = options.debounce_text_changes or 0,
+      },
+      settings = settings,
+      on_exit = function(...)
+        vim.rpcnotify(1, 'exit', ...)
+      end,
+    }
+  end, M.fake_lsp_code, M.fake_lsp_logfile, timeout_ms or 1e3)
 end
 
 --- @class test.lsp.Config
@@ -193,13 +187,12 @@ function M.test_rpc_server(config)
       -- Otherwise I would just return the value here.
       return function(...)
         return exec_lua(function(...)
-          local name0 = ...
-          if type(_G.TEST_RPC_CLIENT[name0]) == 'function' then
-            return _G.TEST_RPC_CLIENT[name0](select(2, ...))
+          if type(_G.TEST_RPC_CLIENT[name]) == 'function' then
+            return _G.TEST_RPC_CLIENT[name](...)
           else
-            return _G.TEST_RPC_CLIENT[name0]
+            return _G.TEST_RPC_CLIENT[name]
           end
-        end, name, ...)
+        end, ...)
       end
     end,
   })
diff --git a/test/functional/plugin/lsp/utils_spec.lua b/test/functional/plugin/lsp/utils_spec.lua
index 6c6dec0667..c1f56f2722 100644
--- a/test/functional/plugin/lsp/utils_spec.lua
+++ b/test/functional/plugin/lsp/utils_spec.lua
@@ -11,21 +11,11 @@ describe('vim.lsp.util', function()
 
   describe('stylize_markdown', function()
     local stylize_markdown = function(content, opts)
-      return exec_lua(
-        [[
-        local bufnr = vim.uri_to_bufnr("file:///fake/uri")
+      return exec_lua(function()
+        local bufnr = vim.uri_to_bufnr('file:///fake/uri')
         vim.fn.bufload(bufnr)
-
-        local args = { ... }
-        local content = args[1]
-        local opts = args[2]
-        local stripped_content = vim.lsp.util.stylize_markdown(bufnr, content, opts)
-
-        return stripped_content
-      ]],
-        content,
-        opts
-      )
+        return vim.lsp.util.stylize_markdown(bufnr, content, opts)
+      end)
     end
 
     it('code fences', function()
@@ -95,7 +85,7 @@ describe('vim.lsp.util', function()
 
   describe('normalize_markdown', function()
     it('collapses consecutive blank lines', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         local lines = {
           'foo',
           '',
@@ -103,25 +93,25 @@ describe('vim.lsp.util', function()
           '',
           'bar',
           '',
-          'baz'
+          'baz',
         }
         return vim.lsp.util._normalize_markdown(lines)
-      ]]
+      end)
       local expected = { 'foo', '', 'bar', '', 'baz' }
       eq(expected, result)
     end)
 
     it('removes preceding and trailing empty lines', function()
-      local result = exec_lua [[
+      local result = exec_lua(function()
         local lines = {
           '',
           'foo',
           'bar',
           '',
-          ''
+          '',
         }
         return vim.lsp.util._normalize_markdown(lines)
-      ]]
+      end)
       local expected = { 'foo', 'bar' }
       eq(expected, result)
     end)
@@ -129,19 +119,14 @@ describe('vim.lsp.util', function()
 
   describe('make_floating_popup_options', function()
     local function assert_anchor(anchor_bias, expected_anchor)
-      local opts = exec_lua(
-        [[
-          local args = { ... }
-          local anchor_bias = args[1]
-          return vim.lsp.util.make_floating_popup_options(30, 10, { anchor_bias = anchor_bias })
-        ]],
-        anchor_bias
-      )
+      local opts = exec_lua(function()
+        return vim.lsp.util.make_floating_popup_options(30, 10, { anchor_bias = anchor_bias })
+      end)
 
       eq(expected_anchor, string.sub(opts.anchor, 1, 1))
     end
 
-    local screen
+    local screen --- @type test.functional.ui.screen
     before_each(function()
       n.clear()
       screen = Screen.new(80, 80)
@@ -221,9 +206,9 @@ describe('vim.lsp.util', function()
       end)
 
       it('bordered window truncates dimensions correctly', function()
-        local opts = exec_lua([[
+        local opts = exec_lua(function()
           return vim.lsp.util.make_floating_popup_options(100, 100, { border = 'single' })
-        ]])
+        end)
 
         eq(56, opts.height)
       end)
diff --git a/test/functional/plugin/lsp_spec.lua b/test/functional/plugin/lsp_spec.lua
index 88b0e0c991..9956fdf628 100644
--- a/test/functional/plugin/lsp_spec.lua
+++ b/test/functional/plugin/lsp_spec.lua
@@ -36,10 +36,10 @@ local test_rpc_server = t_lsp.test_rpc_server
 local create_tcp_echo_server = t_lsp.create_tcp_echo_server
 
 local function get_buf_option(name, bufnr)
-  bufnr = bufnr or 'BUFFER'
-  return exec_lua(
-    string.format("return vim.api.nvim_get_option_value('%s', { buf = %s })", name, bufnr)
-  )
+  return exec_lua(function()
+    bufnr = bufnr or _G.BUFFER
+    return vim.api.nvim_get_option_value(name, { buf = bufnr })
+  end)
 end
 
 local function make_edit(y_0, x_0, y_1, x_1, text)
@@ -62,7 +62,9 @@ local function apply_text_edits(edits, encoding)
     end,
     edits
   )
-  exec_lua('vim.lsp.util.apply_text_edits(...)', edits1, 1, encoding or 'utf-16')
+  exec_lua(function()
+    vim.lsp.util.apply_text_edits(edits1, 1, encoding or 'utf-16')
+  end)
 end
 
 -- TODO(justinmk): hangs on Windows https://github.com/neovim/neovim/pull/11837
@@ -90,19 +92,19 @@ describe('LSP', function()
       -- Run an instance of nvim on the file which contains our "scripts".
       -- Pass TEST_NAME to pick the script.
       local test_name = 'basic_init'
-      exec_lua(function(test_name0, fake_lsp_code0, fake_lsp_logfile0)
+      exec_lua(function()
         _G.lsp = require('vim.lsp')
         function _G.test__start_client()
           return vim.lsp.start_client {
             cmd_env = {
-              NVIM_LOG_FILE = fake_lsp_logfile0,
+              NVIM_LOG_FILE = fake_lsp_logfile,
               NVIM_APPNAME = 'nvim_lsp_test',
             },
             cmd = {
               vim.v.progpath,
               '-l',
-              fake_lsp_code0,
-              test_name0,
+              fake_lsp_code,
+              test_name,
             },
             workspace_folders = {
               {
@@ -113,12 +115,17 @@ describe('LSP', function()
           }
         end
         _G.TEST_CLIENT1 = _G.test__start_client()
-      end, test_name, fake_lsp_code, fake_lsp_logfile)
+      end)
     end)
 
     it('start_client(), stop_client()', function()
       retry(nil, 4000, function()
-        eq(1, exec_lua('return #lsp.get_clients()'))
+        eq(
+          1,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
       eq(
         2,
@@ -135,20 +142,54 @@ describe('LSP', function()
         end)
       )
       retry(nil, 4000, function()
-        eq(3, exec_lua('return #lsp.get_clients()'))
+        eq(
+          3,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
 
-      eq(false, exec_lua('return lsp.get_client_by_id(TEST_CLIENT1) == nil'))
-      eq(false, exec_lua('return lsp.get_client_by_id(TEST_CLIENT1).is_stopped()'))
-      exec_lua('return lsp.get_client_by_id(TEST_CLIENT1).stop()')
+      eq(
+        false,
+        exec_lua(function()
+          return vim.lsp.get_client_by_id(_G.TEST_CLIENT1) == nil
+        end)
+      )
+      eq(
+        false,
+        exec_lua(function()
+          return vim.lsp.get_client_by_id(_G.TEST_CLIENT1).is_stopped()
+        end)
+      )
+      exec_lua(function()
+        return vim.lsp.get_client_by_id(_G.TEST_CLIENT1).stop()
+      end)
       retry(nil, 4000, function()
-        eq(2, exec_lua('return #lsp.get_clients()'))
+        eq(
+          2,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
-      eq(true, exec_lua('return lsp.get_client_by_id(TEST_CLIENT1) == nil'))
+      eq(
+        true,
+        exec_lua(function()
+          return vim.lsp.get_client_by_id(_G.TEST_CLIENT1) == nil
+        end)
+      )
 
-      exec_lua('lsp.stop_client({TEST_CLIENT2, TEST_CLIENT3})')
+      exec_lua(function()
+        vim.lsp.stop_client({ _G.TEST_CLIENT2, _G.TEST_CLIENT3 })
+      end)
       retry(nil, 4000, function()
-        eq(0, exec_lua('return #lsp.get_clients()'))
+        eq(
+          0,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
     end)
 
@@ -158,12 +199,24 @@ describe('LSP', function()
         _G.TEST_CLIENT3 = _G.test__start_client()
       end)
       retry(nil, 4000, function()
-        eq(3, exec_lua('return #lsp.get_clients()'))
+        eq(
+          3,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
       -- Stop all clients.
-      exec_lua('lsp.stop_client(lsp.get_clients())')
+      exec_lua(function()
+        vim.lsp.stop_client(vim.lsp.get_clients())
+      end)
       retry(nil, 4000, function()
-        eq(0, exec_lua('return #lsp.get_clients()'))
+        eq(
+          0,
+          exec_lua(function()
+            return #vim.lsp.get_clients()
+          end)
+        )
       end)
     end)
   end)
@@ -306,10 +359,20 @@ describe('LSP', function()
           exec_lua(function()
             _G.BUFFER = vim.api.nvim_create_buf(false, true)
           end)
-          eq(true, exec_lua('return lsp.buf_attach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)'))
-          eq(true, exec_lua('return lsp.buf_is_attached(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)'))
+          eq(
+            true,
+            exec_lua(function()
+              return vim.lsp.buf_attach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+            end)
+          )
+          eq(
+            true,
+            exec_lua(function()
+              return vim.lsp.buf_is_attached(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+            end)
+          )
           exec_lua(function()
-            vim.api.nvim_command(_G.BUFFER .. 'bwipeout')
+            vim.cmd(_G.BUFFER .. 'bwipeout')
           end)
         end,
         on_init = function(_client)
@@ -323,8 +386,15 @@ describe('LSP', function()
         on_handler = function(err, result, ctx)
           eq(table.remove(expected_handlers), { err, result, ctx }, 'expected handler')
           if ctx.method == 'finish' then
-            exec_lua('return vim.lsp.buf_detach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)')
-            eq(false, exec_lua('return vim.lsp.buf_is_attached(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)'))
+            exec_lua(function()
+              return vim.lsp.buf_detach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+            end)
+            eq(
+              false,
+              exec_lua(function()
+                return vim.lsp.buf_is_attached(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+              end)
+            )
             client.stop()
           end
         end,
@@ -354,13 +424,20 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          eq(true, exec_lua('return vim.lsp.buf_attach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)'))
+          eq(
+            true,
+            exec_lua(function()
+              return vim.lsp.buf_attach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+            end)
+          )
           client.notify('finish')
         end,
         on_handler = function(_, _, ctx)
           if ctx.method == 'finish' then
             eq('basic_init', api.nvim_get_var('lsp_attached'))
-            exec_lua('return vim.lsp.buf_detach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)')
+            exec_lua(function()
+              return vim.lsp.buf_detach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
+            end)
             eq('basic_init', api.nvim_get_var('lsp_detached'))
             client.stop()
           end
@@ -388,7 +465,7 @@ describe('LSP', function()
             eq(
               true,
               exec_lua(function()
-                local keymap
+                local keymap --- @type table<string,any>
                 vim._with({ buf = _G.BUFFER }, function()
                   keymap = vim.fn.maparg('K', 'n', false, true)
                 end)
@@ -405,7 +482,7 @@ describe('LSP', function()
           eq(
             '',
             exec_lua(function()
-              local keymap
+              local keymap --- @type string
               vim._with({ buf = _G.BUFFER }, function()
                 keymap = vim.fn.maparg('K', 'n', false, false)
               end)
@@ -418,40 +495,42 @@ describe('LSP', function()
 
     it('should overwrite options set by ftplugins', function()
       local client --- @type vim.lsp.Client
+      local BUFFER_1 --- @type integer
+      local BUFFER_2 --- @type integer
       test_rpc_server {
         test_name = 'set_defaults_all_capabilities',
         on_init = function(_client)
           client = _client
           exec_lua(function()
             vim.api.nvim_command('filetype plugin on')
-            _G.BUFFER_1 = vim.api.nvim_create_buf(false, true)
-            _G.BUFFER_2 = vim.api.nvim_create_buf(false, true)
-            vim.api.nvim_set_option_value('filetype', 'man', { buf = _G.BUFFER_1 })
-            vim.api.nvim_set_option_value('filetype', 'xml', { buf = _G.BUFFER_2 })
+            BUFFER_1 = vim.api.nvim_create_buf(false, true)
+            BUFFER_2 = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_set_option_value('filetype', 'man', { buf = BUFFER_1 })
+            vim.api.nvim_set_option_value('filetype', 'xml', { buf = BUFFER_2 })
           end)
 
           -- Sanity check to ensure that some values are set after setting filetype.
-          eq("v:lua.require'man'.goto_tag", get_buf_option('tagfunc', '_G.BUFFER_1'))
-          eq('xmlcomplete#CompleteTags', get_buf_option('omnifunc', '_G.BUFFER_2'))
-          eq('xmlformat#Format()', get_buf_option('formatexpr', '_G.BUFFER_2'))
+          eq("v:lua.require'man'.goto_tag", get_buf_option('tagfunc', BUFFER_1))
+          eq('xmlcomplete#CompleteTags', get_buf_option('omnifunc', BUFFER_2))
+          eq('xmlformat#Format()', get_buf_option('formatexpr', BUFFER_2))
 
           exec_lua(function()
-            vim.lsp.buf_attach_client(_G.BUFFER_1, _G.TEST_RPC_CLIENT_ID)
-            vim.lsp.buf_attach_client(_G.BUFFER_2, _G.TEST_RPC_CLIENT_ID)
+            vim.lsp.buf_attach_client(BUFFER_1, _G.TEST_RPC_CLIENT_ID)
+            vim.lsp.buf_attach_client(BUFFER_2, _G.TEST_RPC_CLIENT_ID)
           end)
         end,
         on_handler = function(_, _, ctx)
           if ctx.method == 'test' then
-            eq('v:lua.vim.lsp.tagfunc', get_buf_option('tagfunc', '_G.BUFFER_1'))
-            eq('v:lua.vim.lsp.omnifunc', get_buf_option('omnifunc', '_G.BUFFER_2'))
-            eq('v:lua.vim.lsp.formatexpr()', get_buf_option('formatexpr', '_G.BUFFER_2'))
+            eq('v:lua.vim.lsp.tagfunc', get_buf_option('tagfunc', BUFFER_1))
+            eq('v:lua.vim.lsp.omnifunc', get_buf_option('omnifunc', BUFFER_2))
+            eq('v:lua.vim.lsp.formatexpr()', get_buf_option('formatexpr', BUFFER_2))
             client.stop()
           end
         end,
         on_exit = function(_, _)
-          eq('', get_buf_option('tagfunc', '_G.BUFFER_1'))
-          eq('', get_buf_option('omnifunc', '_G.BUFFER_2'))
-          eq('', get_buf_option('formatexpr', '_G.BUFFER_2'))
+          eq('', get_buf_option('tagfunc', BUFFER_1))
+          eq('', get_buf_option('omnifunc', BUFFER_2))
+          eq('', get_buf_option('formatexpr', BUFFER_2))
         end,
       }
     end)
@@ -620,13 +699,18 @@ describe('LSP', function()
             end)
           end
           if ctx.method == 'workspace/configuration' then
-            local server_result = exec_lua(function(method, params)
+            local server_result = exec_lua(
+              [[
+              local method, params = ...
               return require 'vim.lsp.handlers'['workspace/configuration'](
                 err,
                 params,
                 { method = method, client_id = _G.TEST_RPC_CLIENT_ID }
               )
-            end, ctx.method, result)
+              ]],
+              ctx.method,
+              result
+            )
             client.notify('workspace/configuration', server_result)
           end
           if ctx.method == 'shutdown' then
@@ -673,7 +757,9 @@ describe('LSP', function()
         test_name = 'basic_check_capabilities',
         on_init = function(client)
           client.stop()
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq({ includeText = false }, client.server_capabilities().textDocumentSync.save)
           eq(false, client.server_capabilities().codeLensProvider)
@@ -802,15 +888,15 @@ describe('LSP', function()
           if ctx.method == 'start' then
             local tmpfile_old = tmpname()
             local tmpfile_new = tmpname(false)
-            exec_lua(function(oldname, newname)
+            exec_lua(function()
               _G.BUFFER = vim.api.nvim_get_current_buf()
-              vim.api.nvim_buf_set_name(_G.BUFFER, oldname)
+              vim.api.nvim_buf_set_name(_G.BUFFER, tmpfile_old)
               vim.api.nvim_buf_set_lines(_G.BUFFER, 0, -1, true, { 'help me' })
               vim.lsp.buf_attach_client(_G.BUFFER, _G.TEST_RPC_CLIENT_ID)
               vim._with({ buf = _G.BUFFER }, function()
-                vim.cmd('saveas ' .. newname)
+                vim.cmd('saveas ' .. tmpfile_new)
               end)
-            end, tmpfile_old, tmpfile_new)
+            end)
           else
             client.stop()
           end
@@ -904,7 +990,9 @@ describe('LSP', function()
         end,
         on_init = function(client)
           client.stop()
-          exec_lua('vim.lsp.buf.type_definition()')
+          exec_lua(function()
+            vim.lsp.buf.type_definition()
+          end)
         end,
         on_exit = function(code, signal)
           eq(0, code, 'exit code')
@@ -931,7 +1019,9 @@ describe('LSP', function()
           end,
           on_init = function(client)
             client.stop()
-            exec_lua('vim.lsp.buf.type_definition()')
+            exec_lua(function()
+              vim.lsp.buf.type_definition()
+            end)
           end,
           on_exit = function(code, signal)
             eq(0, code, 'exit code')
@@ -1032,7 +1122,7 @@ describe('LSP', function()
             local request = exec_lua(function()
               return _G.TEST_RPC_CLIENT.requests[2]
             end)
-            eq(NIL, request)
+            eq(nil, request)
             client.notify('finish')
           end
           if ctx.method == 'finish' then
@@ -1070,7 +1160,7 @@ describe('LSP', function()
           local request = exec_lua(function()
             return _G.TEST_RPC_CLIENT.requests[2]
           end)
-          eq(NIL, request)
+          eq(nil, request)
           if ctx.method == 'finish' then
             client.stop()
           end
@@ -1113,7 +1203,7 @@ describe('LSP', function()
             local request = exec_lua(function()
               return _G.TEST_RPC_CLIENT.requests[2]
             end)
-            eq(NIL, request)
+            eq(nil, request)
             client.notify('finish')
           end
           if ctx.method == 'finish' then
@@ -1182,7 +1272,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           client.notify('finish')
@@ -1223,7 +1315,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1269,7 +1363,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1312,7 +1408,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1361,7 +1459,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local full_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(full_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1478,8 +1578,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local sync_kind =
-            exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
+          local sync_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Incremental
+          end)
           eq(sync_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1531,8 +1632,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local sync_kind =
-            exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
+          local sync_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Incremental
+          end)
           eq(sync_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1581,8 +1683,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local sync_kind =
-            exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
+          local sync_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Incremental
+          end)
           eq(sync_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1626,7 +1729,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local sync_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(sync_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -1677,7 +1782,9 @@ describe('LSP', function()
         end,
         on_init = function(_client)
           client = _client
-          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          local sync_kind = exec_lua(function()
+            return require 'vim.lsp.protocol'.TextDocumentSyncKind.Full
+          end)
           eq(sync_kind, client.server_capabilities().textDocumentSync.change)
           eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua(function()
@@ -2179,7 +2286,9 @@ describe('LSP', function()
     end)
 
     it('correctly goes ahead with the edit if all is normal', function()
-      exec_lua("vim.lsp.util.apply_text_document_edit(..., nil, 'utf-16')", text_document_edit(5))
+      exec_lua(function(text_edit)
+        vim.lsp.util.apply_text_document_edit(text_edit, nil, 'utf-16')
+      end, text_document_edit(5))
       eq({
         'First ↥ 🤦 🦄 line of text',
         '2nd line of 语text',
@@ -2187,10 +2296,10 @@ describe('LSP', function()
     end)
 
     it('always accepts edit with version = 0', function()
-      exec_lua(function(bufnr, text_edit)
-        vim.lsp.util.buf_versions[bufnr] = 10
+      exec_lua(function(text_edit)
+        vim.lsp.util.buf_versions[target_bufnr] = 10
         vim.lsp.util.apply_text_document_edit(text_edit, nil, 'utf-16')
-      end, target_bufnr, text_document_edit(0))
+      end, text_document_edit(0))
       eq({
         'First ↥ 🤦 🦄 line of text',
         '2nd line of 语text',
@@ -2199,10 +2308,10 @@ describe('LSP', function()
 
     it('skips the edit if the version of the edit is behind the local buffer ', function()
       local apply_edit_mocking_current_version = function(edit, versionedBuf)
-        exec_lua(function(edit0, versionedBuf0)
-          vim.lsp.util.buf_versions[versionedBuf0.bufnr] = versionedBuf0.currentVersion
-          vim.lsp.util.apply_text_document_edit(edit0, nil, 'utf-16')
-        end, edit, versionedBuf)
+        exec_lua(function()
+          vim.lsp.util.buf_versions[versionedBuf.bufnr] = versionedBuf.currentVersion
+          vim.lsp.util.apply_text_document_edit(edit, nil, 'utf-16')
+        end)
       end
 
       local baseText = {
@@ -2295,34 +2404,30 @@ describe('LSP', function()
       }
     end
 
-    local target_bufnr, changedtick = nil, nil
+    local target_bufnr --- @type integer
+    local changedtick --- @type integer
 
     before_each(function()
-      local ret = exec_lua(function()
-        local bufnr = vim.uri_to_bufnr('file:///fake/uri')
+      exec_lua(function()
+        target_bufnr = vim.uri_to_bufnr('file:///fake/uri')
         local lines = {
           'Original Line #1',
           'Original Line #2',
         }
 
-        vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
+        vim.api.nvim_buf_set_lines(target_bufnr, 0, -1, false, lines)
 
-        local update_changed_tick = function()
-          vim.lsp.util.buf_versions[bufnr] = vim.api.nvim_buf_get_var(bufnr, 'changedtick')
+        local function update_changed_tick()
+          vim.lsp.util.buf_versions[target_bufnr] = vim.b[target_bufnr].changedtick
         end
 
         update_changed_tick()
-        vim.api.nvim_buf_attach(bufnr, false, {
-          on_changedtick = function()
-            update_changed_tick()
-          end,
+        vim.api.nvim_buf_attach(target_bufnr, false, {
+          on_changedtick = update_changed_tick,
         })
 
-        return { bufnr, vim.api.nvim_buf_get_var(bufnr, 'changedtick') }
+        changedtick = vim.b[target_bufnr].changedtick
       end)
-
-      target_bufnr = ret[1]
-      changedtick = ret[2]
     end)
 
     it('apply_workspace_edit applies a single edit', function()
@@ -2340,11 +2445,11 @@ describe('LSP', function()
           'First Line',
           'Original Line #2',
         },
-        exec_lua(function(workspace_edits, target_bufnr0)
+        exec_lua(function(workspace_edits)
           vim.lsp.util.apply_workspace_edit(workspace_edits, 'utf-16')
 
-          return vim.api.nvim_buf_get_lines(target_bufnr0, 0, -1, false)
-        end, make_workspace_edit(edits), target_bufnr)
+          return vim.api.nvim_buf_get_lines(target_bufnr, 0, -1, false)
+        end, make_workspace_edit(edits))
       )
     end)
 
@@ -2361,11 +2466,10 @@ describe('LSP', function()
 
       eq(
         new_lines,
-        exec_lua(function(workspace_edits, target_bufnr0)
+        exec_lua(function(workspace_edits)
           vim.lsp.util.apply_workspace_edit(workspace_edits, 'utf-16')
-
-          return vim.api.nvim_buf_get_lines(target_bufnr0, 0, -1, false)
-        end, make_workspace_edit(edits), target_bufnr)
+          return vim.api.nvim_buf_get_lines(target_bufnr, 0, -1, false)
+        end, make_workspace_edit(edits))
       )
     end)
 
@@ -2380,7 +2484,9 @@ describe('LSP', function()
           },
         },
       }
-      exec_lua('vim.lsp.util.apply_workspace_edit(...)', edit, 'utf-16')
+      exec_lua(function()
+        vim.lsp.util.apply_workspace_edit(edit, 'utf-16')
+      end)
       eq(true, vim.uv.fs_stat(tmpfile) ~= nil)
     end)
 
@@ -2397,7 +2503,9 @@ describe('LSP', function()
             },
           },
         }
-        exec_lua('vim.lsp.util.apply_workspace_edit(...)', edit, 'utf-16')
+        exec_lua(function()
+          vim.lsp.util.apply_workspace_edit(edit, 'utf-16')
+        end)
         eq(true, vim.uv.fs_stat(tmpfile) ~= nil)
       end
     )
@@ -2446,11 +2554,11 @@ describe('LSP', function()
     it('DeleteFile delete file and buffer', function()
       local tmpfile = tmpname()
       write_file(tmpfile, 'Be gone')
-      local uri = exec_lua(function(fname)
-        local bufnr = vim.fn.bufadd(fname)
+      local uri = exec_lua(function()
+        local bufnr = vim.fn.bufadd(tmpfile)
         vim.fn.bufload(bufnr)
-        return vim.uri_from_fname(fname)
-      end, tmpfile)
+        return vim.uri_from_fname(tmpfile)
+      end)
       local edit = {
         documentChanges = {
           {
@@ -2490,15 +2598,15 @@ describe('LSP', function()
       local old = tmpname()
       write_file(old, 'Test content')
       local new = tmpname(false)
-      local lines = exec_lua(function(old0, new0)
-        local old_bufnr = vim.fn.bufadd(old0)
+      local lines = exec_lua(function()
+        local old_bufnr = vim.fn.bufadd(old)
         vim.fn.bufload(old_bufnr)
-        vim.lsp.util.rename(old0, new0)
+        vim.lsp.util.rename(old, new)
         -- the existing buffer is renamed in-place and its contents is kept
-        local new_bufnr = vim.fn.bufadd(new0)
+        local new_bufnr = vim.fn.bufadd(new)
         vim.fn.bufload(new_bufnr)
         return (old_bufnr == new_bufnr) and vim.api.nvim_buf_get_lines(new_bufnr, 0, -1, true)
-      end, old, new)
+      end)
       eq({ 'Test content' }, lines)
       local exists = vim.uv.fs_stat(old) ~= nil
       eq(false, exists)
@@ -2517,15 +2625,15 @@ describe('LSP', function()
       local file = 'file.txt'
       write_file(old_dir .. pathsep .. file, 'Test content')
 
-      local lines = exec_lua(function(old_dir0, new_dir0, pathsep0, file0)
-        local old_bufnr = vim.fn.bufadd(old_dir0 .. pathsep0 .. file0)
+      local lines = exec_lua(function()
+        local old_bufnr = vim.fn.bufadd(old_dir .. pathsep .. file)
         vim.fn.bufload(old_bufnr)
-        vim.lsp.util.rename(old_dir0, new_dir0)
+        vim.lsp.util.rename(old_dir, new_dir)
         -- the existing buffer is renamed in-place and its contents is kept
-        local new_bufnr = vim.fn.bufadd(new_dir0 .. pathsep0 .. file0)
+        local new_bufnr = vim.fn.bufadd(new_dir .. pathsep .. file)
         vim.fn.bufload(new_bufnr)
         return (old_bufnr == new_bufnr) and vim.api.nvim_buf_get_lines(new_bufnr, 0, -1, true)
-      end, old_dir, new_dir, pathsep, file)
+      end)
       eq({ 'Test content' }, lines)
       eq(false, vim.uv.fs_stat(old_dir) ~= nil)
       eq(true, vim.uv.fs_stat(new_dir) ~= nil)
@@ -2541,18 +2649,18 @@ describe('LSP', function()
 
       eq(
         true,
-        exec_lua(function(old0, new0)
-          local old_prefixed = 'explorer://' .. old0
-          local old_suffixed = old0 .. '.bak'
-          local new_prefixed = 'explorer://' .. new0
-          local new_suffixed = new0 .. '.bak'
+        exec_lua(function()
+          local old_prefixed = 'explorer://' .. old
+          local old_suffixed = old .. '.bak'
+          local new_prefixed = 'explorer://' .. new
+          local new_suffixed = new .. '.bak'
 
           local old_prefixed_buf = vim.fn.bufadd(old_prefixed)
           local old_suffixed_buf = vim.fn.bufadd(old_suffixed)
           local new_prefixed_buf = vim.fn.bufadd(new_prefixed)
           local new_suffixed_buf = vim.fn.bufadd(new_suffixed)
 
-          vim.lsp.util.rename(old0, new0)
+          vim.lsp.util.rename(old, new)
 
           return vim.api.nvim_buf_is_valid(old_prefixed_buf)
             and vim.api.nvim_buf_is_valid(old_suffixed_buf)
@@ -2562,7 +2670,7 @@ describe('LSP', function()
             and vim.api.nvim_buf_get_name(old_suffixed_buf) == old_suffixed
             and vim.api.nvim_buf_get_name(new_prefixed_buf) == new_prefixed
             and vim.api.nvim_buf_get_name(new_suffixed_buf) == new_suffixed
-        end, old, new)
+        end)
       )
 
       os.remove(new)
@@ -2576,16 +2684,16 @@ describe('LSP', function()
         local new = tmpname()
         write_file(new, 'New file')
 
-        exec_lua(function(old0, new0)
-          vim.lsp.util.rename(old0, new0, { ignoreIfExists = true })
-        end, old, new)
+        exec_lua(function()
+          vim.lsp.util.rename(old, new, { ignoreIfExists = true })
+        end)
 
         eq(true, vim.uv.fs_stat(old) ~= nil)
         eq('New file', read_file(new))
 
-        exec_lua(function(old0, new0)
-          vim.lsp.util.rename(old0, new0, { overwrite = false })
-        end, old, new)
+        exec_lua(function()
+          vim.lsp.util.rename(old, new, { overwrite = false })
+        end)
 
         eq(true, vim.uv.fs_stat(old) ~= nil)
         eq('New file', read_file(new))
@@ -2597,20 +2705,20 @@ describe('LSP', function()
       write_file(old, 'line')
       local new = tmpname(false)
 
-      local undo_kept = exec_lua(function(old0, new0)
+      local undo_kept = exec_lua(function()
         vim.opt.undofile = true
-        vim.cmd.edit(old0)
+        vim.cmd.edit(old)
         vim.cmd.normal('dd')
         vim.cmd.write()
         local undotree = vim.fn.undotree()
-        vim.lsp.util.rename(old0, new0)
+        vim.lsp.util.rename(old, new)
         -- Renaming uses :saveas, which updates the "last write" information.
         -- Other than that, the undotree should remain the same.
         undotree.save_cur = undotree.save_cur + 1
         undotree.save_last = undotree.save_last + 1
         undotree.entries[1].save = undotree.entries[1].save + 1
         return vim.deep_equal(undotree, vim.fn.undotree())
-      end, old, new)
+      end)
       eq(false, vim.uv.fs_stat(old) ~= nil)
       eq(true, vim.uv.fs_stat(new) ~= nil)
       eq(true, undo_kept)
@@ -2621,17 +2729,17 @@ describe('LSP', function()
       write_file(old, 'line')
       local new = tmpname(false)
 
-      local undo_kept = exec_lua(function(old0, new0)
+      local undo_kept = exec_lua(function()
         vim.opt.undofile = true
-        vim.cmd.split(old0)
+        vim.cmd.split(old)
         vim.cmd.normal('dd')
         vim.cmd.write()
         local undotree = vim.fn.undotree()
         vim.cmd.bdelete()
-        vim.lsp.util.rename(old0, new0)
-        vim.cmd.edit(new0)
+        vim.lsp.util.rename(old, new)
+        vim.cmd.edit(new)
         return vim.deep_equal(undotree, vim.fn.undotree())
-      end, old, new)
+      end)
       eq(false, vim.uv.fs_stat(old) ~= nil)
       eq(true, vim.uv.fs_stat(new) ~= nil)
       eq(true, undo_kept)
@@ -2642,16 +2750,16 @@ describe('LSP', function()
       write_file(old, 'Old File')
       local new = tmpname(false)
 
-      local lines = exec_lua(function(old0, new0)
-        local old_buf = vim.fn.bufadd(old0)
+      local lines = exec_lua(function()
+        local old_buf = vim.fn.bufadd(old)
         vim.fn.bufload(old_buf)
         local conflict_buf = vim.api.nvim_create_buf(true, false)
-        vim.api.nvim_buf_set_name(conflict_buf, new0)
+        vim.api.nvim_buf_set_name(conflict_buf, new)
         vim.api.nvim_buf_set_lines(conflict_buf, 0, -1, true, { 'conflict' })
         vim.api.nvim_win_set_buf(0, conflict_buf)
-        vim.lsp.util.rename(old0, new0)
+        vim.lsp.util.rename(old, new)
         return vim.api.nvim_buf_get_lines(conflict_buf, 0, -1, true)
-      end, old, new)
+      end)
       eq({ 'conflict' }, lines)
       eq('Old File', read_file(old))
     end)
@@ -2661,9 +2769,9 @@ describe('LSP', function()
       write_file(old, 'Old file')
       local new = tmpname()
       write_file(new, 'New file')
-      exec_lua(function(old0, new0)
-        vim.lsp.util.rename(old0, new0, { overwrite = true })
-      end, old, new)
+      exec_lua(function()
+        vim.lsp.util.rename(old, new, { overwrite = true })
+      end)
 
       eq(false, vim.uv.fs_stat(old) ~= nil)
       eq(true, vim.uv.fs_stat(new) ~= nil)
@@ -3028,14 +3136,39 @@ describe('LSP', function()
 
   describe('lsp.util._get_symbol_kind_name', function()
     it('returns the name specified by protocol', function()
-      eq('File', exec_lua('return vim.lsp.util._get_symbol_kind_name(1)'))
-      eq('TypeParameter', exec_lua('return vim.lsp.util._get_symbol_kind_name(26)'))
+      eq(
+        'File',
+        exec_lua(function()
+          return vim.lsp.util._get_symbol_kind_name(1)
+        end)
+      )
+      eq(
+        'TypeParameter',
+        exec_lua(function()
+          return vim.lsp.util._get_symbol_kind_name(26)
+        end)
+      )
     end)
 
     it('returns the name not specified by protocol', function()
-      eq('Unknown', exec_lua('return vim.lsp.util._get_symbol_kind_name(nil)'))
-      eq('Unknown', exec_lua('return vim.lsp.util._get_symbol_kind_name(vim.NIL)'))
-      eq('Unknown', exec_lua('return vim.lsp.util._get_symbol_kind_name(1000)'))
+      eq(
+        'Unknown',
+        exec_lua(function()
+          return vim.lsp.util._get_symbol_kind_name(nil)
+        end)
+      )
+      eq(
+        'Unknown',
+        exec_lua(function()
+          return vim.lsp.util._get_symbol_kind_name(vim.NIL)
+        end)
+      )
+      eq(
+        'Unknown',
+        exec_lua(function()
+          return vim.lsp.util._get_symbol_kind_name(1000)
+        end)
+      )
     end)
   end)
 
@@ -3397,7 +3530,12 @@ describe('LSP', function()
       ]],
         shiftwidth
       ))
-      eq(tabsize, exec_lua('return vim.lsp.util.get_effective_tabstop()'))
+      eq(
+        tabsize,
+        exec_lua(function()
+          return vim.lsp.util.get_effective_tabstop()
+        end)
+      )
     end
 
     it('with shiftwidth = 1', function()
@@ -4119,6 +4257,7 @@ describe('LSP', function()
               local bufnr = vim.api.nvim_get_current_buf()
               vim.lsp.buf_attach_client(bufnr, _G.TEST_RPC_CLIENT_ID)
               vim.lsp._stubs = {}
+              --- @diagnostic disable-next-line:duplicate-set-field
               vim.fn.input = function(opts, _)
                 vim.lsp._stubs.input_prompt = opts.prompt
                 vim.lsp._stubs.input_text = opts.default
@@ -4140,12 +4279,24 @@ describe('LSP', function()
 
             eq(table.remove(test.expected_handlers), { err, result, ctx }, 'expected handler')
             if ctx.method == 'start' then
-              exec_lua('vim.lsp.buf.rename()')
+              exec_lua(function()
+                vim.lsp.buf.rename()
+              end)
             end
             if ctx.method == 'shutdown' then
               if test.expected_text then
-                eq('New Name: ', exec_lua('return vim.lsp._stubs.input_prompt'))
-                eq(test.expected_text, exec_lua('return vim.lsp._stubs.input_text'))
+                eq(
+                  'New Name: ',
+                  exec_lua(function()
+                    return vim.lsp._stubs.input_prompt
+                  end)
+                )
+                eq(
+                  test.expected_text,
+                  exec_lua(function()
+                    return vim.lsp._stubs.input_text
+                  end)
+                )
               end
               client.stop()
             end
@@ -4181,6 +4332,7 @@ describe('LSP', function()
               end
               local bufnr = vim.api.nvim_get_current_buf()
               vim.lsp.buf_attach_client(bufnr, _G.TEST_RPC_CLIENT_ID)
+              --- @diagnostic disable-next-line:duplicate-set-field
               vim.fn.inputlist = function()
                 return 1
               end
@@ -4398,8 +4550,8 @@ describe('LSP', function()
           eq(table.remove(expected_handlers), { err, result, ctx })
           if ctx.method == 'start' then
             local fake_uri = 'file:///fake/uri'
-            local cmd = exec_lua(function(fake_uri0)
-              local bufnr = vim.uri_to_bufnr(fake_uri0)
+            local cmd = exec_lua(function()
+              local bufnr = vim.uri_to_bufnr(fake_uri)
               vim.fn.bufload(bufnr)
               vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, { 'One line' })
               local lenses = {
@@ -4423,7 +4575,7 @@ describe('LSP', function()
               vim.api.nvim_set_current_buf(bufnr)
               vim.lsp.codelens.run()
               return cmd_called
-            end, fake_uri)
+            end)
             eq({ command = 'Dummy', title = 'Lens1' }, cmd)
           elseif ctx.method == 'shutdown' then
             client.stop()
@@ -4530,7 +4682,7 @@ describe('LSP', function()
       exec_lua(create_server_definition)
 
       -- setup lsp
-      exec_lua(function(lens_title_per_fake_uri0)
+      exec_lua(function()
         local server = _G._create_server({
           capabilities = {
             codeLensProvider = {
@@ -4546,7 +4698,7 @@ describe('LSP', function()
                     ['end'] = { line = 0, character = 0 },
                   },
                   command = {
-                    title = lens_title_per_fake_uri0[params.textDocument.uri],
+                    title = lens_title_per_fake_uri[params.textDocument.uri],
                     command = 'Dummy',
                   },
                 },
@@ -4560,12 +4712,12 @@ describe('LSP', function()
           name = 'dummy',
           cmd = server.cmd,
         })
-      end, lens_title_per_fake_uri)
+      end)
 
       -- create buffers and setup handler
-      exec_lua(function(lens_title_per_fake_uri0)
+      exec_lua(function()
         local default_buf = vim.api.nvim_get_current_buf()
-        for fake_uri in pairs(lens_title_per_fake_uri0) do
+        for fake_uri in pairs(lens_title_per_fake_uri) do
           local bufnr = vim.uri_to_bufnr(fake_uri)
           vim.api.nvim_set_current_buf(bufnr)
           vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, { 'Some contents' })
@@ -4573,14 +4725,14 @@ describe('LSP', function()
         end
         vim.api.nvim_buf_delete(default_buf, { force = true })
 
-        _G.REQUEST_COUNT = vim.tbl_count(lens_title_per_fake_uri0)
+        _G.REQUEST_COUNT = vim.tbl_count(lens_title_per_fake_uri)
         _G.RESPONSES = {}
         local on_codelens = vim.lsp.codelens.on_codelens
         vim.lsp.codelens.on_codelens = function(err, result, ctx, ...)
           table.insert(_G.RESPONSES, { err = err, result = result, ctx = ctx })
           return on_codelens(err, result, ctx, ...)
         end
-      end, lens_title_per_fake_uri)
+      end)
 
       -- call codelens refresh
       local cmds = exec_lua(function()
@@ -4655,7 +4807,7 @@ describe('LSP', function()
               vim.notify = notify
               return notify_msg
             end)
-            eq(NIL, notify_msg)
+            eq(nil, notify_msg)
           elseif ctx.method == 'shutdown' then
             client.stop()
           end
@@ -4696,7 +4848,7 @@ describe('LSP', function()
               vim.notify = notify
               return notify_msg
             end)
-            eq(NIL, notify_msg)
+            eq(nil, notify_msg)
           elseif ctx.method == 'shutdown' then
             client.stop()
           end
@@ -4743,7 +4895,7 @@ describe('LSP', function()
               vim.notify = notify
               return notify_msg
             end)
-            eq(NIL, notify_msg)
+            eq(nil, notify_msg)
           elseif ctx.method == 'shutdown' then
             client.stop()
           end
@@ -4893,18 +5045,23 @@ describe('LSP', function()
       --- @param range_formatting boolean
       local function check_notify(name, formatting, range_formatting)
         local timeout_msg = '[LSP][' .. name .. '] timeout'
-        exec_lua(function(formatting0, range_formatting0, name0)
+        exec_lua(function()
           local server = _G._create_server({
             capabilities = {
-              documentFormattingProvider = formatting0,
-              documentRangeFormattingProvider = range_formatting0,
+              documentFormattingProvider = formatting,
+              documentRangeFormattingProvider = range_formatting,
             },
           })
-          vim.lsp.start({ name = name0, cmd = server.cmd })
+          vim.lsp.start({ name = name, cmd = server.cmd })
           _G.notify_msg = nil
-          vim.lsp.buf.format({ name = name0, timeout_ms = 1 })
-        end, formatting, range_formatting, name)
-        eq(formatting and timeout_msg or fail_msg, exec_lua('return notify_msg'))
+          vim.lsp.buf.format({ name = name, timeout_ms = 1 })
+        end)
+        eq(
+          formatting and timeout_msg or fail_msg,
+          exec_lua(function()
+            return _G.notify_msg
+          end)
+        )
         exec_lua(function()
           _G.notify_msg = nil
           vim.lsp.buf.format({
@@ -4919,7 +5076,12 @@ describe('LSP', function()
             },
           })
         end)
-        eq(range_formatting and timeout_msg or fail_msg, exec_lua('return notify_msg'))
+        eq(
+          range_formatting and timeout_msg or fail_msg,
+          exec_lua(function()
+            return _G.notify_msg
+          end)
+        )
       end
       check_notify('none', false, false)
       check_notify('formatting', true, false)
@@ -4949,8 +5111,8 @@ describe('LSP', function()
         },
       }
       exec_lua(create_server_definition)
-      exec_lua(function(mock_locations0)
-        _G.mock_locations = mock_locations0
+      exec_lua(function()
+        _G.mock_locations = mock_locations
         _G.server = _G._create_server({
           ---@type lsp.ServerCapabilities
           capabilities = {
@@ -4981,7 +5143,7 @@ describe('LSP', function()
           },
         })
         _G.client_id = vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
-      end, mock_locations)
+      end)
     end)
 
     after_each(function()
@@ -5062,22 +5224,22 @@ describe('LSP', function()
 
     it('can connect to lsp server via pipe or domain_socket', function()
       local tmpfile = is_os('win') and '\\\\.\\\\pipe\\pipe.test' or tmpname(false)
-      local result = exec_lua(function(SOCK)
+      local result = exec_lua(function()
         local uv = vim.uv
         local server = assert(uv.new_pipe(false))
-        server:bind(SOCK)
+        server:bind(tmpfile)
         local init = nil
 
         server:listen(127, function(err)
           assert(not err, err)
-          local client = assert(uv.new_pipe())
+          local client = assert(vim.uv.new_pipe())
           server:accept(client)
           client:read_start(require('vim.lsp.rpc').create_read_loop(function(body)
             init = body
             client:close()
           end))
         end)
-        vim.lsp.start({ name = 'dummy', cmd = vim.lsp.rpc.connect(SOCK) })
+        vim.lsp.start({ name = 'dummy', cmd = vim.lsp.rpc.connect(tmpfile) })
         vim.wait(1000, function()
           return init ~= nil
         end)
@@ -5085,7 +5247,7 @@ describe('LSP', function()
         server:close()
         server:shutdown()
         return vim.json.decode(init)
-      end, tmpfile)
+      end)
       eq('initialize', result.method)
     end)
   end)
@@ -5093,14 +5255,13 @@ describe('LSP', function()
   describe('handlers', function()
     it('handler can return false as response', function()
       local result = exec_lua(function()
-        local uv = vim.uv
-        local server = assert(uv.new_tcp())
+        local server = assert(vim.uv.new_tcp())
         local messages = {}
         local responses = {}
         server:bind('127.0.0.1', 0)
         server:listen(127, function(err)
           assert(not err, err)
-          local socket = assert(uv.new_tcp())
+          local socket = assert(vim.uv.new_tcp())
           server:accept(socket)
           socket:read_start(require('vim.lsp.rpc').create_read_loop(function(body)
             local payload = vim.json.decode(body)
@@ -5176,12 +5337,12 @@ describe('LSP', function()
       end
 
       exec_lua(create_server_definition)
-      local result = exec_lua(function(root_dir0, tmpfile0)
+      local result = exec_lua(function()
         local server = _G._create_server()
         local client_id = assert(vim.lsp.start({
           name = 'dynamic-test',
           cmd = server.cmd,
-          root_dir = root_dir0,
+          root_dir = root_dir,
           get_language_id = function()
             return 'dummy-lang'
           end,
@@ -5205,7 +5366,7 @@ describe('LSP', function()
               registerOptions = {
                 documentSelector = {
                   {
-                    pattern = root_dir0 .. '/*.foo',
+                    pattern = root_dir .. '/*.foo',
                   },
                 },
               },
@@ -5250,13 +5411,13 @@ describe('LSP', function()
         end
 
         check('textDocument/formatting')
-        check('textDocument/formatting', tmpfile0)
+        check('textDocument/formatting', tmpfile)
         check('textDocument/rangeFormatting')
-        check('textDocument/rangeFormatting', tmpfile0)
+        check('textDocument/rangeFormatting', tmpfile)
         check('textDocument/completion')
 
         return result
-      end, root_dir, tmpfile)
+      end)
 
       eq(5, #result)
       eq({ method = 'textDocument/formatting', supported = false }, result[1])
@@ -5268,6 +5429,16 @@ describe('LSP', function()
   end)
 
   describe('vim.lsp._watchfiles', function()
+    --- @type integer, integer, integer
+    local created, changed, deleted
+
+    setup(function()
+      clear()
+      created = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]])
+      changed = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]])
+      deleted = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]])
+    end)
+
     local function test_filechanges(watchfunc)
       it(
         string.format('sends notifications when files change (watchfunc=%s)', watchfunc),
@@ -5298,12 +5469,12 @@ describe('LSP', function()
           mkdir(root_dir)
 
           exec_lua(create_server_definition)
-          local result = exec_lua(function(root_dir0, watchfunc0)
+          local result = exec_lua(function()
             local server = _G._create_server()
             local client_id = assert(vim.lsp.start({
               name = 'watchfiles-test',
               cmd = server.cmd,
-              root_dir = root_dir0,
+              root_dir = root_dir,
               capabilities = {
                 workspace = {
                   didChangeWatchedFiles = {
@@ -5313,11 +5484,11 @@ describe('LSP', function()
               },
             }))
 
-            require('vim.lsp._watchfiles')._watchfunc = require('vim._watch')[watchfunc0]
+            require('vim.lsp._watchfiles')._watchfunc = require('vim._watch')[watchfunc]
 
             local expected_messages = 0
 
-            local msg_wait_timeout = watchfunc0 == 'watch' and 200 or 2500
+            local msg_wait_timeout = watchfunc == 'watch' and 200 or 2500
 
             local function wait_for_message(incr)
               expected_messages = expected_messages + (incr or 1)
@@ -5349,11 +5520,11 @@ describe('LSP', function()
               },
             }, { client_id = client_id })
 
-            if watchfunc0 ~= 'watch' then
+            if watchfunc ~= 'watch' then
               vim.wait(100)
             end
 
-            local path = root_dir0 .. '/watch'
+            local path = root_dir .. '/watch'
             local tmp = vim.fn.tempname()
             io.open(tmp, 'w'):close()
             vim.uv.fs_rename(tmp, path)
@@ -5367,7 +5538,7 @@ describe('LSP', function()
             vim.lsp.stop_client(client_id)
 
             return server.messages
-          end, root_dir, watchfunc)
+          end)
 
           local uri = vim.uri_from_fname(root_dir .. '/watch')
 
@@ -5378,7 +5549,7 @@ describe('LSP', function()
             params = {
               changes = {
                 {
-                  type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+                  type = created,
                   uri = uri,
                 },
               },
@@ -5390,7 +5561,7 @@ describe('LSP', function()
             params = {
               changes = {
                 {
-                  type = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]]),
+                  type = deleted,
                   uri = uri,
                 },
               },
@@ -5407,12 +5578,12 @@ describe('LSP', function()
     it('correctly registers and unregisters', function()
       local root_dir = '/some_dir'
       exec_lua(create_server_definition)
-      local result = exec_lua(function(root_dir0)
+      local result = exec_lua(function()
         local server = _G._create_server()
         local client_id = assert(vim.lsp.start({
           name = 'watchfiles-test',
           cmd = server.cmd,
-          root_dir = root_dir0,
+          root_dir = root_dir,
           capabilities = {
             workspace = {
               didChangeWatchedFiles = {
@@ -5464,8 +5635,8 @@ describe('LSP', function()
           },
         }, { client_id = client_id })
 
-        send_event(root_dir0 .. '/file.watch0', vim._watch.FileChangeType.Created)
-        send_event(root_dir0 .. '/file.watch1', vim._watch.FileChangeType.Created)
+        send_event(root_dir .. '/file.watch0', vim._watch.FileChangeType.Created)
+        send_event(root_dir .. '/file.watch1', vim._watch.FileChangeType.Created)
 
         expected_messages = expected_messages + 1
         wait_for_messages()
@@ -5495,14 +5666,14 @@ describe('LSP', function()
           },
         }, { client_id = client_id })
 
-        send_event(root_dir0 .. '/file.watch0', vim._watch.FileChangeType.Created)
-        send_event(root_dir0 .. '/file.watch1', vim._watch.FileChangeType.Created)
+        send_event(root_dir .. '/file.watch0', vim._watch.FileChangeType.Created)
+        send_event(root_dir .. '/file.watch1', vim._watch.FileChangeType.Created)
 
         expected_messages = expected_messages + 1
         wait_for_messages()
 
         return server.messages
-      end, root_dir)
+      end)
 
       local function watched_uri(fname)
         return vim.uri_from_fname(root_dir .. '/' .. fname)
@@ -5513,7 +5684,7 @@ describe('LSP', function()
       eq({
         changes = {
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('file.watch0'),
           },
         },
@@ -5522,7 +5693,7 @@ describe('LSP', function()
       eq({
         changes = {
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('file.watch1'),
           },
         },
@@ -5532,12 +5703,12 @@ describe('LSP', function()
     it('correctly handles the registered watch kind', function()
       local root_dir = 'some_dir'
       exec_lua(create_server_definition)
-      local result = exec_lua(function(root_dir0)
+      local result = exec_lua(function()
         local server = _G._create_server()
         local client_id = assert(vim.lsp.start({
           name = 'watchfiles-test',
           cmd = server.cmd,
-          root_dir = root_dir0,
+          root_dir = root_dir,
           capabilities = {
             workspace = {
               didChangeWatchedFiles = {
@@ -5611,7 +5782,7 @@ describe('LSP', function()
         wait_for_messages()
 
         return server.messages
-      end, root_dir)
+      end)
 
       local function watched_uri(fname)
         return vim.uri_from_fname('/dir/' .. fname)
@@ -5622,51 +5793,51 @@ describe('LSP', function()
       eq({
         changes = {
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('watch1'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]]),
+            type = changed,
             uri = watched_uri('watch2'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('watch3'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]]),
+            type = changed,
             uri = watched_uri('watch3'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]]),
+            type = deleted,
             uri = watched_uri('watch4'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('watch5'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]]),
+            type = deleted,
             uri = watched_uri('watch5'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]]),
+            type = changed,
             uri = watched_uri('watch6'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]]),
+            type = deleted,
             uri = watched_uri('watch6'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = watched_uri('watch7'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]]),
+            type = changed,
             uri = watched_uri('watch7'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Deleted]]),
+            type = deleted,
             uri = watched_uri('watch7'),
           },
         },
@@ -5676,12 +5847,12 @@ describe('LSP', function()
     it('prunes duplicate events', function()
       local root_dir = 'some_dir'
       exec_lua(create_server_definition)
-      local result = exec_lua(function(root_dir0)
+      local result = exec_lua(function()
         local server = _G._create_server()
         local client_id = assert(vim.lsp.start({
           name = 'watchfiles-test',
           cmd = server.cmd,
-          root_dir = root_dir0,
+          root_dir = root_dir,
           capabilities = {
             workspace = {
               didChangeWatchedFiles = {
@@ -5738,22 +5909,22 @@ describe('LSP', function()
         wait_for_messages()
 
         return server.messages
-      end, root_dir)
+      end)
 
       eq(3, #result)
       eq('workspace/didChangeWatchedFiles', result[3].method)
       eq({
         changes = {
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = vim.uri_from_fname('file1'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Changed]]),
+            type = changed,
             uri = vim.uri_from_fname('file1'),
           },
           {
-            type = exec_lua([[return vim.lsp.protocol.FileChangeType.Created]]),
+            type = created,
             uri = vim.uri_from_fname('file2'),
           },
         },
@@ -5772,13 +5943,13 @@ describe('LSP', function()
       end)
 
       local function check_registered(capabilities)
-        return exec_lua(function(capabilities0)
+        return exec_lua(function()
           _G.watching = false
           local client_id = assert(vim.lsp.start({
             name = 'watchfiles-test',
             cmd = _G.server.cmd,
             root_dir = 'some_dir',
-            capabilities = capabilities0,
+            capabilities = capabilities,
           }, {
             reuse_client = function()
               return false
@@ -5813,7 +5984,7 @@ describe('LSP', function()
 
           vim.lsp.stop_client(client_id, true)
           return _G.watching
-        end, capabilities)
+        end)
       end
 
       eq(is_os('mac') or is_os('win'), check_registered(nil)) -- start{_client}() defaults to make_client_capabilities().
diff --git a/test/functional/plugin/man_spec.lua b/test/functional/plugin/man_spec.lua
index 057748f51d..6f0eeff748 100644
--- a/test/functional/plugin/man_spec.lua
+++ b/test/functional/plugin/man_spec.lua
@@ -16,21 +16,20 @@ local is_ci = t.is_ci
 
 -- Collects all names passed to find_path() after attempting ":Man foo".
 local function get_search_history(name)
-  local args = vim.split(name, ' ')
-  local code = [[
-    local args = ...
+  return exec_lua(function()
+    local args = vim.split(name, ' ')
     local man = require('man')
     local res = {}
-    man.find_path = function(sect, name)
-      table.insert(res, {sect, name})
+    --- @diagnostic disable-next-line:duplicate-set-field
+    man.find_path = function(sect, name0)
+      table.insert(res, { sect, name0 })
       return nil
     end
-    local ok, rv = pcall(man.open_page, -1, {tab = 0}, args)
+    local ok, rv = pcall(man.open_page, -1, { tab = 0 }, args)
     assert(not ok)
     assert(rv and rv:match('no manual entry'))
     return res
-  ]]
-  return exec_lua(code, args)
+  end)
 end
 
 clear()
diff --git a/test/functional/plugin/tohtml_spec.lua b/test/functional/plugin/tohtml_spec.lua
index 98a422935c..1d05f4d6b4 100644
--- a/test/functional/plugin/tohtml_spec.lua
+++ b/test/functional/plugin/tohtml_spec.lua
@@ -210,9 +210,7 @@ describe(':TOhtml', function()
     exec('set termguicolors')
     local bg = fn.synIDattr(fn.hlID('Normal'), 'bg#', 'gui')
     local fg = fn.synIDattr(fn.hlID('Normal'), 'fg#', 'gui')
-    exec_lua [[
-    local html = vim.cmd'2,2TOhtml'
-    ]]
+    n.command('2,2TOhtml')
     local out_file = api.nvim_buf_get_name(api.nvim_get_current_buf())
     eq({
       '<!DOCTYPE html>',
@@ -408,12 +406,12 @@ describe(':TOhtml', function()
     local function run()
       local buf = api.nvim_get_current_buf()
       run_tohtml_and_assert(screen, function()
-        exec_lua [[
-        local outfile = vim.fn.tempname() .. '.html'
-        local html = require('tohtml').tohtml(0,{number_lines=true})
-        vim.fn.writefile(html, outfile)
-        vim.cmd.split(outfile)
-        ]]
+        exec_lua(function()
+          local outfile = vim.fn.tempname() .. '.html'
+          local html = require('tohtml').tohtml(0, { number_lines = true })
+          vim.fn.writefile(html, outfile)
+          vim.cmd.split(outfile)
+        end)
       end)
       api.nvim_set_current_buf(buf)
     end