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

30 files changed, 4864 insertions, 2185 deletions

diff --git a/test/functional/lua/api_spec.lua b/test/functional/lua/api_spec.lua
index 56969150bd..741ed0cf6e 100644
--- a/test/functional/lua/api_spec.lua
+++ b/test/functional/lua/api_spec.lua
@@ -145,10 +145,10 @@ describe('luaeval(vim.api.…)', function()
     eq(true, fn.luaeval('vim.api.nvim__id(vim.api.nvim__id)(true)'))
     eq(
       42,
-      exec_lua [[
-      local f = vim.api.nvim__id({42, vim.api.nvim__id})
-      return f[2](f[1])
-    ]]
+      exec_lua(function()
+        local f = vim.api.nvim__id({ 42, vim.api.nvim__id })
+        return f[2](f[1])
+      end)
     )
   end)
 
@@ -224,42 +224,39 @@ describe('luaeval(vim.api.…)', function()
   end)
 
   it('correctly converts dictionaries with type_idx to API objects', function()
-    eq(
-      4,
-      eval([[type(luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))]])
-    )
+    eq(4, eval([[type(luaeval('vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary})'))]]))
 
-    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary})'))
+    eq({}, fn.luaeval('vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary})'))
 
     eq(
       { v = { 42 } },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { foo = 2 },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
+        'vim.api.nvim__id_dict({[vim.type_idx]=vim.types.dictionary, [vim.val_idx]=10, [5]=1, foo=2, [1]=42})'
       )
     )
     eq(
       { v = 10 },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.float, [vim.val_idx]=10, [5]=1, foo=2, [1]=42}})'
       )
     )
     eq(
       { v = {} },
       fn.luaeval(
-        'vim.api.nvim__id_dictionary({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2}})'
+        'vim.api.nvim__id_dict({v={[vim.type_idx]=vim.types.array, [vim.val_idx]=10, [5]=1, foo=2}})'
       )
     )
 
-    -- If API requests dictionary, then empty table will be the one. This is not
+    -- If API requests dict, then empty table will be the one. This is not
     -- the case normally because empty table is an empty array.
-    eq({}, fn.luaeval('vim.api.nvim__id_dictionary({})'))
-    eq(4, eval([[type(luaeval('vim.api.nvim__id_dictionary({})'))]]))
+    eq({}, fn.luaeval('vim.api.nvim__id_dict({})'))
+    eq(4, eval([[type(luaeval('vim.api.nvim__id_dict({})'))]]))
   end)
 
   it('converts booleans in positional args', function()
@@ -365,12 +362,12 @@ describe('luaeval(vim.api.…)', function()
 
     eq(
       [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'dct': Expected Lua table]],
-      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_dictionary(1)")]]))
+      remove_trace(exc_exec([[call luaeval("vim.api.nvim__id_dict(1)")]]))
     )
     eq(
       [[Vim(call):E5108: Error executing lua [string "luaeval()"]:1: Invalid 'dct': Expected Dict-like Lua table]],
       remove_trace(
-        exc_exec([[call luaeval("vim.api.nvim__id_dictionary({[vim.type_idx]=vim.types.array})")]])
+        exc_exec([[call luaeval("vim.api.nvim__id_dict({[vim.type_idx]=vim.types.array})")]])
       )
     )
 
diff --git a/test/functional/lua/buffer_updates_spec.lua b/test/functional/lua/buffer_updates_spec.lua
index d4af7e4732..f277868b1c 100644
--- a/test/functional/lua/buffer_updates_spec.lua
+++ b/test/functional/lua/buffer_updates_spec.lua
@@ -27,30 +27,35 @@ local origlines = {
 
 before_each(function()
   clear()
-  exec_lua [[
-    local evname = ...
+  exec_lua(function()
     local events = {}
 
-    function test_register(bufnr, evname, id, changedtick, utf_sizes, preview)
+    function _G.test_register(bufnr, evname, id, changedtick, utf_sizes, preview)
       local function callback(...)
-        table.insert(events, {id, ...})
-        if test_unreg == id then
+        table.insert(events, { id, ... })
+        if _G.test_unreg == id then
           return true
         end
       end
-      local opts = {[evname]=callback, on_detach=callback, on_reload=callback, utf_sizes=utf_sizes, preview=preview}
+      local opts = {
+        [evname] = callback,
+        on_detach = callback,
+        on_reload = callback,
+        utf_sizes = utf_sizes,
+        preview = preview,
+      }
       if changedtick then
         opts.on_changedtick = callback
       end
       vim.api.nvim_buf_attach(bufnr, false, opts)
     end
 
-    function get_events()
+    function _G.get_events()
       local ret_events = events
       events = {}
       return ret_events
     end
-  ]]
+  end)
 end)
 
 describe('lua buffer event callbacks: on_lines', function()
@@ -257,13 +262,13 @@ describe('lua buffer event callbacks: on_lines', function()
 
   it('has valid cursor position while shifting', function()
     api.nvim_buf_set_lines(0, 0, -1, true, { 'line1' })
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function()
           vim.api.nvim_set_var('listener_cursor_line', vim.api.nvim_win_get_cursor(0)[1])
         end,
       })
-    ]])
+    end)
     feed('>>')
     eq(1, api.nvim_get_var('listener_cursor_line'))
   end)
@@ -277,19 +282,19 @@ describe('lua buffer event callbacks: on_lines', function()
   end)
 
   it('does not SEGFAULT when accessing window buffer info in on_detach #14998', function()
-    local code = [[
+    local code = function()
       local buf = vim.api.nvim_create_buf(false, false)
 
-      vim.cmd"split"
+      vim.cmd 'split'
       vim.api.nvim_win_set_buf(0, buf)
 
       vim.api.nvim_buf_attach(buf, false, {
-        on_detach = function(_, buf)
+        on_detach = function(_, buf0)
           vim.fn.tabpagebuflist()
-          vim.fn.win_findbuf(buf)
-        end
+          vim.fn.win_findbuf(buf0)
+        end,
       })
-    ]]
+    end
 
     exec_lua(code)
     command('q!')
@@ -302,13 +307,13 @@ describe('lua buffer event callbacks: on_lines', function()
 
   it('#12718 lnume', function()
     api.nvim_buf_set_lines(0, 0, -1, true, { '1', '2', '3' })
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function(...)
           vim.api.nvim_set_var('linesev', { ... })
         end,
       })
-    ]])
+    end)
     feed('1G0')
     feed('y<C-v>2j')
     feed('G0')
@@ -326,13 +331,13 @@ describe('lua buffer event callbacks: on_lines', function()
   end)
 
   it('nvim_buf_call() from callback does not cause wrong Normal mode CTRL-A #16729', function()
-    exec_lua([[
+    exec_lua(function()
       vim.api.nvim_buf_attach(0, false, {
-        on_lines = function(...)
+        on_lines = function()
           vim.api.nvim_buf_call(0, function() end)
         end,
       })
-    ]])
+    end)
     feed('itest123<Esc><C-A>')
     eq('test124', api.nvim_get_current_line())
   end)
@@ -342,19 +347,19 @@ describe('lua buffer event callbacks: on_lines', function()
     screen:attach()
 
     api.nvim_buf_set_lines(0, 0, -1, true, { 'aaa', 'bbb', 'ccc' })
-    exec_lua([[
+    exec_lua(function()
       local ns = vim.api.nvim_create_namespace('')
       vim.api.nvim_buf_attach(0, false, {
         on_lines = function(_, _, _, row, _, end_row)
           vim.api.nvim_buf_clear_namespace(0, ns, row, end_row)
           for i = row, end_row - 1 do
-            local id = vim.api.nvim_buf_set_extmark(0, ns, i, 0, {
-              virt_text = {{ 'NEW' .. tostring(i), 'WarningMsg' }},
+            vim.api.nvim_buf_set_extmark(0, ns, i, 0, {
+              virt_text = { { 'NEW' .. tostring(i), 'WarningMsg' } },
             })
           end
         end,
       })
-    ]])
+    end)
 
     feed('o')
     screen:expect({
@@ -379,6 +384,25 @@ describe('lua buffer event callbacks: on_lines', function()
       ]],
     })
   end)
+
+  it('line lengths are correct when pressing TAB with folding #29119', function()
+    api.nvim_buf_set_lines(0, 0, -1, true, { 'a', 'b' })
+
+    exec_lua(function()
+      _G.res = {}
+      vim.o.foldmethod = 'indent'
+      vim.o.softtabstop = -1
+      vim.api.nvim_buf_attach(0, false, {
+        on_lines = function(_, bufnr, _, row, _, end_row)
+          local lines = vim.api.nvim_buf_get_lines(bufnr, row, end_row, true)
+          table.insert(_G.res, lines)
+        end,
+      })
+    end)
+
+    feed('i<Tab>')
+    eq({ '\ta' }, exec_lua('return _G.res[#_G.res]'))
+  end)
 end)
 
 describe('lua: nvim_buf_attach on_bytes', function()
diff --git a/test/functional/lua/command_line_completion_spec.lua b/test/functional/lua/command_line_completion_spec.lua
index 2ba432133b..f8786a45bb 100644
--- a/test/functional/lua/command_line_completion_spec.lua
+++ b/test/functional/lua/command_line_completion_spec.lua
@@ -5,12 +5,14 @@ local clear = n.clear
 local eq = t.eq
 local exec_lua = n.exec_lua
 
+--- @return { [1]: string[], [2]: integer }
 local get_completions = function(input, env)
-  return exec_lua('return {vim._expand_pat(...)}', input, env)
+  return exec_lua('return { vim._expand_pat(...) }', input, env)
 end
 
+--- @return { [1]: string[], [2]: integer }
 local get_compl_parts = function(parts)
-  return exec_lua('return {vim._expand_pat_get_parts(...)}', parts)
+  return exec_lua('return { vim._expand_pat_get_parts(...) }', parts)
 end
 
 before_each(clear)
@@ -123,6 +125,171 @@ describe('nlua_expand_pat', function()
     )
   end)
 
+  describe('should complete vim.fn', function()
+    it('correctly works for simple completion', function()
+      local actual = get_completions('vim.fn.did')
+      local expected = {
+        { 'did_filetype' },
+        #'vim.fn.',
+      }
+      eq(expected, actual)
+    end)
+    it('should not suggest items with #', function()
+      exec_lua [[
+        -- ensure remote#host#... functions exist
+        vim.cmd [=[
+          runtime! autoload/remote/host.vim
+        ]=]
+        -- make a dummy call to ensure vim.fn contains an entry: remote#host#...
+        vim.fn['remote#host#IsRunning']('python3')
+      ]]
+      local actual = get_completions('vim.fn.remo')
+      local expected = {
+        { 'remove' }, -- there should be no completion "remote#host#..."
+        #'vim.fn.',
+      }
+      eq(expected, actual)
+    end)
+  end)
+
+  describe('should complete for variable accessors for', function()
+    it('vim.v', function()
+      local actual = get_completions('vim.v.t_')
+      local expected = {
+        { 't_blob', 't_bool', 't_dict', 't_float', 't_func', 't_list', 't_number', 't_string' },
+        #'vim.v.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.g', function()
+      exec_lua [[
+        vim.cmd [=[
+          let g:nlua_foo = 'completion'
+          let g:nlua_foo_bar = 'completion'
+          let g:nlua_foo#bar = 'nocompletion'  " should be excluded from lua completion
+        ]=]
+      ]]
+      local actual = get_completions('vim.g.nlua')
+      local expected = {
+        { 'nlua_foo', 'nlua_foo_bar' },
+        #'vim.g.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.b', function()
+      exec_lua [[
+        vim.b.nlua_foo_buf = 'bar'
+        vim.b.some_other_vars = 'bar'
+      ]]
+      local actual = get_completions('vim.b.nlua')
+      local expected = {
+        { 'nlua_foo_buf' },
+        #'vim.b.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.w', function()
+      exec_lua [[
+        vim.w.nlua_win_var = 42
+      ]]
+      local actual = get_completions('vim.w.nlua')
+      local expected = {
+        { 'nlua_win_var' },
+        #'vim.w.',
+      }
+      eq(expected, actual)
+    end)
+
+    it('vim.t', function()
+      exec_lua [[
+        vim.t.nlua_tab_var = 42
+      ]]
+      local actual = get_completions('vim.t.')
+      local expected = {
+        { 'nlua_tab_var' },
+        #'vim.t.',
+      }
+      eq(expected, actual)
+    end)
+  end)
+
+  describe('should complete for option accessors for', function()
+    -- for { vim.o, vim.go, vim.opt, vim.opt_local, vim.opt_global }
+    local test_opt = function(accessor)
+      do
+        local actual = get_completions(accessor .. '.file')
+        local expected = {
+          'fileencoding',
+          'fileencodings',
+          'fileformat',
+          'fileformats',
+          'fileignorecase',
+          'filetype',
+        }
+        eq({ expected, #accessor + 1 }, actual, accessor .. '.file')
+      end
+      do
+        local actual = get_completions(accessor .. '.winh')
+        local expected = {
+          'winheight',
+          'winhighlight',
+        }
+        eq({ expected, #accessor + 1 }, actual, accessor .. '.winh')
+      end
+    end
+
+    test_opt('vim.o')
+    test_opt('vim.go')
+    test_opt('vim.opt')
+    test_opt('vim.opt_local')
+    test_opt('vim.opt_global')
+
+    it('vim.o, suggesting all the known options', function()
+      local completions = get_completions('vim.o.')[1] ---@type string[]
+      eq(
+        exec_lua [[
+        return vim.tbl_count(vim.api.nvim_get_all_options_info())
+      ]],
+        #completions
+      )
+    end)
+
+    it('vim.bo', function()
+      do
+        local actual = get_completions('vim.bo.file')
+        local compls = {
+          -- should contain buffer options only
+          'fileencoding',
+          'fileformat',
+          'filetype',
+        }
+        eq({ compls, #'vim.bo.' }, actual)
+      end
+      do
+        local actual = get_completions('vim.bo.winh')
+        local compls = {}
+        eq({ compls, #'vim.bo.' }, actual)
+      end
+    end)
+
+    it('vim.wo', function()
+      do
+        local actual = get_completions('vim.wo.file')
+        local compls = {}
+        eq({ compls, #'vim.wo.' }, actual)
+      end
+      do
+        local actual = get_completions('vim.wo.winh')
+        -- should contain window options only
+        local compls = { 'winhighlight' }
+        eq({ compls, #'vim.wo.' }, actual)
+      end
+    end)
+  end)
+
   it('should return everything if the input is of length 0', function()
     eq({ { 'other', 'vim' }, 0 }, get_completions('', { vim = true, other = true }))
   end)
diff --git a/test/functional/lua/commands_spec.lua b/test/functional/lua/commands_spec.lua
index 57b084d3d6..456ee13da2 100644
--- a/test/functional/lua/commands_spec.lua
+++ b/test/functional/lua/commands_spec.lua
@@ -178,13 +178,15 @@ describe(':lua', function()
     eq('hello', exec_capture(':lua = x()'))
     exec_lua('x = {a = 1, b = 2}')
     eq('{\n  a = 1,\n  b = 2\n}', exec_capture(':lua  =x'))
-    exec_lua([[function x(success)
-      if success then
-        return true, "Return value"
-      else
-        return false, nil, "Error message"
+    exec_lua(function()
+      function _G.x(success)
+        if success then
+          return true, 'Return value'
+        else
+          return false, nil, 'Error message'
+        end
       end
-    end]])
+    end)
     eq(
       dedent [[
       true
diff --git a/test/functional/lua/deprecated_spec.lua b/test/functional/lua/deprecated_spec.lua
new file mode 100644
index 0000000000..fee34336cc
--- /dev/null
+++ b/test/functional/lua/deprecated_spec.lua
@@ -0,0 +1,22 @@
+local t = require('test.testutil')
+local n = require('test.functional.testnvim')()
+
+local clear = n.clear
+local exec_lua = n.exec_lua
+local eq = t.eq
+
+describe('deprecated lua code', function()
+  before_each(clear)
+
+  describe('vim.treesitter.get_parser()', function()
+    it('returns nil for versions >= 0.12', function()
+      local result = exec_lua(function()
+        if vim.version.ge(vim.version(), '0.12') then
+          return vim.treesitter.get_parser(0, 'borklang')
+        end
+        return nil
+      end)
+      eq(nil, result)
+    end)
+  end)
+end)
diff --git a/test/functional/lua/diagnostic_spec.lua b/test/functional/lua/diagnostic_spec.lua
index 05082bc132..4ae1146703 100644
--- a/test/functional/lua/diagnostic_spec.lua
+++ b/test/functional/lua/diagnostic_spec.lua
@@ -1,7 +1,6 @@
 local t = require('test.testutil')
 local n = require('test.functional.testnvim')()
 
-local NIL = vim.NIL
 local command = n.command
 local clear = n.clear
 local exec_lua = n.exec_lua
@@ -15,10 +14,10 @@ describe('vim.diagnostic', function()
   before_each(function()
     clear()
 
-    exec_lua [[
+    exec_lua(function()
       require('vim.diagnostic')
 
-      function make_diagnostic(msg, lnum, col, end_lnum, end_col, severity, source, code)
+      local function make_diagnostic(msg, lnum, col, end_lnum, end_col, severity, source, code)
         return {
           lnum = lnum,
           col = col,
@@ -31,54 +30,97 @@ describe('vim.diagnostic', function()
         }
       end
 
-      function make_error(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.ERROR, source, code)
+      function _G.make_error(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.ERROR,
+          source,
+          code
+        )
       end
 
-      function make_warning(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.WARN, source, code)
+      function _G.make_warning(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.WARN,
+          source,
+          code
+        )
       end
 
-      function make_info(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.INFO, source, code)
+      function _G.make_info(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.INFO,
+          source,
+          code
+        )
       end
 
-      function make_hint(msg, lnum, col, end_lnum, end_col, source, code)
-        return make_diagnostic(msg, lnum, col, end_lnum, end_col, vim.diagnostic.severity.HINT, source, code)
+      function _G.make_hint(msg, lnum, col, end_lnum, end_col, source, code)
+        return make_diagnostic(
+          msg,
+          lnum,
+          col,
+          end_lnum,
+          end_col,
+          vim.diagnostic.severity.HINT,
+          source,
+          code
+        )
       end
 
-      function count_diagnostics(bufnr, severity, namespace)
-        return #vim.diagnostic.get(bufnr, {severity = severity, namespace = namespace})
+      function _G.count_diagnostics(bufnr, severity, namespace)
+        return #vim.diagnostic.get(bufnr, { severity = severity, namespace = namespace })
       end
 
-      function count_extmarks(bufnr, namespace)
+      function _G.count_extmarks(bufnr, namespace)
         local ns = vim.diagnostic.get_namespace(namespace)
         local extmarks = 0
         if ns.user_data.virt_text_ns then
-          extmarks = extmarks + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {})
+          extmarks = extmarks
+            + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {})
         end
         if ns.user_data.underline_ns then
-          extmarks = extmarks + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {})
+          extmarks = extmarks
+            + #vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {})
         end
         return extmarks
       end
 
-      function get_virt_text_extmarks(ns)
-        local ns = vim.diagnostic.get_namespace(ns)
+      function _G.get_virt_text_extmarks(ns)
+        ns = vim.diagnostic.get_namespace(ns)
         local virt_text_ns = ns.user_data.virt_text_ns
-        return vim.api.nvim_buf_get_extmarks(diagnostic_bufnr, virt_text_ns, 0, -1, {details = true})
+        return vim.api.nvim_buf_get_extmarks(
+          _G.diagnostic_bufnr,
+          virt_text_ns,
+          0,
+          -1,
+          { details = true }
+        )
       end
-    ]]
-
-    exec_lua([[
-      diagnostic_ns = vim.api.nvim_create_namespace("diagnostic_spec")
-      other_ns = vim.api.nvim_create_namespace("other_namespace")
-      diagnostic_bufnr = vim.api.nvim_create_buf(true, false)
-      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)
-      return diagnostic_bufnr
-    ]])
+    end)
+
+    exec_lua(function()
+      _G.diagnostic_ns = vim.api.nvim_create_namespace('diagnostic_spec')
+      _G.other_ns = vim.api.nvim_create_namespace('other_namespace')
+      _G.diagnostic_bufnr = vim.api.nvim_create_buf(true, false)
+      local lines = { '1st line of text', '2nd line of text', 'wow', 'cool', 'more', 'lines' }
+      vim.fn.bufload(_G.diagnostic_bufnr)
+      vim.api.nvim_buf_set_lines(_G.diagnostic_bufnr, 0, 1, false, lines)
+    end)
   end)
 
   it('creates highlight groups', function()
@@ -115,27 +157,28 @@ describe('vim.diagnostic', function()
   end)
 
   it('retrieves diagnostics from all buffers and namespaces', function()
-    local result = exec_lua [[
+    local result = exec_lua(function()
       local other_bufnr = vim.api.nvim_create_buf(true, false)
-      local lines = vim.api.nvim_buf_get_lines(diagnostic_bufnr, 0, -1, true)
+      local lines = vim.api.nvim_buf_get_lines(_G.diagnostic_bufnr, 0, -1, true)
       vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
 
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
+      vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+        _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+        _G.make_error('Diagnostic #2', 2, 1, 2, 1),
       })
-      vim.diagnostic.set(other_ns, other_bufnr, {
-        make_error('Diagnostic #3', 3, 1, 3, 1),
+      vim.diagnostic.set(_G.other_ns, other_bufnr, {
+        _G.make_error('Diagnostic #3', 3, 1, 3, 1),
       })
       return vim.diagnostic.get()
-    ]]
+    end)
     eq(3, #result)
     eq(
       2,
-      exec_lua(
-        [[return #vim.tbl_filter(function(d) return d.bufnr == diagnostic_bufnr end, ...)]],
-        result
-      )
+      exec_lua(function()
+        return #vim.tbl_filter(function(d)
+          return d.bufnr == _G.diagnostic_bufnr
+        end, result)
+      end)
     )
     eq('Diagnostic #1', result[1].message)
   end)
@@ -143,155 +186,171 @@ describe('vim.diagnostic', function()
   it('removes diagnostics from the cache when a buffer is removed', function()
     eq(
       2,
-      exec_lua [[
-      vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-      local other_bufnr = vim.fn.bufadd('test | test')
-      local lines = vim.api.nvim_buf_get_lines(diagnostic_bufnr, 0, -1, true)
-      vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
-      vim.cmd('bunload! ' .. other_bufnr)
-
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
-      })
-      vim.diagnostic.set(diagnostic_ns, other_bufnr, {
-        make_error('Diagnostic #3', 3, 1, 3, 1),
-      })
-      vim.api.nvim_set_current_buf(other_bufnr)
-      vim.opt_local.buflisted = true
-      vim.cmd('bwipeout!')
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+        local other_bufnr = vim.fn.bufadd('test | test')
+        local lines = vim.api.nvim_buf_get_lines(_G.diagnostic_bufnr, 0, -1, true)
+        vim.api.nvim_buf_set_lines(other_bufnr, 0, 1, false, lines)
+        vim.cmd('bunload! ' .. other_bufnr)
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+          _G.make_error('Diagnostic #2', 2, 1, 2, 1),
+        })
+        vim.diagnostic.set(_G.diagnostic_ns, other_bufnr, {
+          _G.make_error('Diagnostic #3', 3, 1, 3, 1),
+        })
+        vim.api.nvim_set_current_buf(other_bufnr)
+        vim.opt_local.buflisted = true
+        vim.cmd('bwipeout!')
+        return #vim.diagnostic.get()
+      end)
     )
     eq(
       2,
-      exec_lua [[
-      vim.api.nvim_set_current_buf(diagnostic_bufnr)
-      vim.opt_local.buflisted = false
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+        vim.opt_local.buflisted = false
+        return #vim.diagnostic.get()
+      end)
     )
     eq(
       0,
-      exec_lua [[
-      vim.cmd('bwipeout!')
-      return #vim.diagnostic.get()
-    ]]
+      exec_lua(function()
+        vim.cmd('bwipeout!')
+        return #vim.diagnostic.get()
+      end)
     )
   end)
 
   it('removes diagnostic from stale cache on reset', function()
-    local diagnostics = exec_lua [[
-      vim.diagnostic.set(diagnostic_ns, diagnostic_bufnr, {
-        make_error('Diagnostic #1', 1, 1, 1, 1),
-        make_error('Diagnostic #2', 2, 1, 2, 1),
+    local diagnostics = exec_lua(function()
+      vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+        _G.make_error('Diagnostic #1', 1, 1, 1, 1),
+        _G.make_error('Diagnostic #2', 2, 1, 2, 1),
       })
-      local other_bufnr = vim.fn.bufadd('test | test')
-      vim.cmd('noautocmd bwipeout! ' .. diagnostic_bufnr)
-      return vim.diagnostic.get(diagnostic_bufnr)
-    ]]
+      vim.fn.bufadd('test | test')
+      vim.cmd('noautocmd bwipeout! ' .. _G.diagnostic_bufnr)
+      re