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

1 files changed, 1559 insertions, 826 deletions

diff --git a/test/functional/lua/vim_spec.lua b/test/functional/lua/vim_spec.lua
index ebe5fc254e..a262d239e8 100644
--- a/test/functional/lua/vim_spec.lua
+++ b/test/functional/lua/vim_spec.lua
@@ -3,22 +3,22 @@ local helpers = require('test.functional.helpers')(after_each)
 local Screen = require('test.functional.ui.screen')
 
 local nvim_prog = helpers.nvim_prog
-local funcs = helpers.funcs
-local meths = helpers.meths
+local fn = helpers.fn
+local api = helpers.api
 local command = helpers.command
 local dedent = helpers.dedent
 local insert = helpers.insert
 local clear = helpers.clear
 local eq = helpers.eq
 local ok = helpers.ok
-local pesc = helpers.pesc
+local pesc = vim.pesc
 local eval = helpers.eval
 local feed = helpers.feed
 local pcall_err = helpers.pcall_err
 local exec_lua = helpers.exec_lua
 local matches = helpers.matches
 local exec = helpers.exec
-local NIL = helpers.NIL
+local NIL = vim.NIL
 local retry = helpers.retry
 local next_msg = helpers.next_msg
 local remove_trace = helpers.remove_trace
@@ -39,204 +39,479 @@ describe('lua stdlib', function()
   -- Note: Built-in Nvim comparison (on systems lacking `strcasecmp`) works
   --       only on ASCII characters.
   it('vim.stricmp', function()
-    eq(0, funcs.luaeval('vim.stricmp("a", "A")'))
-    eq(0, funcs.luaeval('vim.stricmp("A", "a")'))
-    eq(0, funcs.luaeval('vim.stricmp("a", "a")'))
-    eq(0, funcs.luaeval('vim.stricmp("A", "A")'))
-
-    eq(0, funcs.luaeval('vim.stricmp("", "")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0", "\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0\\0", "\\0\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0\\0\\0", "\\0\\0\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0\\0\\0A", "\\0\\0\\0a")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0A")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0a")'))
-
-    eq(0, funcs.luaeval('vim.stricmp("a\\0", "A\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("A\\0", "a\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("a\\0", "a\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("A\\0", "A\\0")'))
-
-    eq(0, funcs.luaeval('vim.stricmp("\\0a", "\\0A")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0A", "\\0a")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0a", "\\0a")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0A", "\\0A")'))
-
-    eq(0, funcs.luaeval('vim.stricmp("\\0a\\0", "\\0A\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0A\\0", "\\0a\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0a\\0", "\\0a\\0")'))
-    eq(0, funcs.luaeval('vim.stricmp("\\0A\\0", "\\0A\\0")'))
-
-    eq(-1, funcs.luaeval('vim.stricmp("a", "B")'))
-    eq(-1, funcs.luaeval('vim.stricmp("A", "b")'))
-    eq(-1, funcs.luaeval('vim.stricmp("a", "b")'))
-    eq(-1, funcs.luaeval('vim.stricmp("A", "B")'))
-
-    eq(-1, funcs.luaeval('vim.stricmp("", "\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0", "\\0\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0\\0", "\\0\\0\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0\\0\\0A", "\\0\\0\\0b")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0B")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0b")'))
-
-    eq(-1, funcs.luaeval('vim.stricmp("a\\0", "B\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("A\\0", "b\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("a\\0", "b\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("A\\0", "B\\0")'))
-
-    eq(-1, funcs.luaeval('vim.stricmp("\\0a", "\\0B")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0A", "\\0b")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0a", "\\0b")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0A", "\\0B")'))
-
-    eq(-1, funcs.luaeval('vim.stricmp("\\0a\\0", "\\0B\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0A\\0", "\\0b\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0a\\0", "\\0b\\0")'))
-    eq(-1, funcs.luaeval('vim.stricmp("\\0A\\0", "\\0B\\0")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("c", "B")'))
-    eq(1, funcs.luaeval('vim.stricmp("C", "b")'))
-    eq(1, funcs.luaeval('vim.stricmp("c", "b")'))
-    eq(1, funcs.luaeval('vim.stricmp("C", "B")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("\\0", "")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0", "\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0\\0", "\\0\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0\\0\\0", "\\0\\0\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0\\0C", "\\0\\0\\0b")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0\\0c", "\\0\\0\\0B")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0\\0\\0c", "\\0\\0\\0b")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("c\\0", "B\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("C\\0", "b\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("c\\0", "b\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("C\\0", "B\\0")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("c\\0", "B")'))
-    eq(1, funcs.luaeval('vim.stricmp("C\\0", "b")'))
-    eq(1, funcs.luaeval('vim.stricmp("c\\0", "b")'))
-    eq(1, funcs.luaeval('vim.stricmp("C\\0", "B")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("\\0c", "\\0B")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0C", "\\0b")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0c", "\\0b")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0C", "\\0B")'))
-
-    eq(1, funcs.luaeval('vim.stricmp("\\0c\\0", "\\0B\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0C\\0", "\\0b\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0c\\0", "\\0b\\0")'))
-    eq(1, funcs.luaeval('vim.stricmp("\\0C\\0", "\\0B\\0")'))
-  end)
-
-  it('vim.deprecate', function()
-    -- vim.deprecate(name, alternative, version, plugin, backtrace)
-    eq(dedent[[
-      foo.bar() is deprecated, use zub.wooo{ok=yay} instead. :help deprecated
-      This feature will be removed in Nvim version 2.17]],
-      exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', '2.17'))
-    -- Same message, skipped.
-    eq(vim.NIL,
-      exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', '2.17'))
-    -- When `plugin` is specified, don't show ":help deprecated". #22235
-    eq(dedent[[
-      foo.bar() is deprecated, use zub.wooo{ok=yay} instead.
-      This feature will be removed in my-plugin.nvim version 0.3.0]],
-      exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', '0.3.0', 'my-plugin.nvim', false))
+    eq(0, fn.luaeval('vim.stricmp("a", "A")'))
+    eq(0, fn.luaeval('vim.stricmp("A", "a")'))
+    eq(0, fn.luaeval('vim.stricmp("a", "a")'))
+    eq(0, fn.luaeval('vim.stricmp("A", "A")'))
+
+    eq(0, fn.luaeval('vim.stricmp("", "")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0", "\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0\\0", "\\0\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0\\0\\0", "\\0\\0\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0\\0\\0A", "\\0\\0\\0a")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0A")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0a")'))
+
+    eq(0, fn.luaeval('vim.stricmp("a\\0", "A\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("A\\0", "a\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("a\\0", "a\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("A\\0", "A\\0")'))
+
+    eq(0, fn.luaeval('vim.stricmp("\\0a", "\\0A")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0A", "\\0a")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0a", "\\0a")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0A", "\\0A")'))
+
+    eq(0, fn.luaeval('vim.stricmp("\\0a\\0", "\\0A\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0A\\0", "\\0a\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0a\\0", "\\0a\\0")'))
+    eq(0, fn.luaeval('vim.stricmp("\\0A\\0", "\\0A\\0")'))
+
+    eq(-1, fn.luaeval('vim.stricmp("a", "B")'))
+    eq(-1, fn.luaeval('vim.stricmp("A", "b")'))
+    eq(-1, fn.luaeval('vim.stricmp("a", "b")'))
+    eq(-1, fn.luaeval('vim.stricmp("A", "B")'))
+
+    eq(-1, fn.luaeval('vim.stricmp("", "\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0", "\\0\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0\\0", "\\0\\0\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0\\0\\0A", "\\0\\0\\0b")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0B")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0\\0\\0a", "\\0\\0\\0b")'))
+
+    eq(-1, fn.luaeval('vim.stricmp("a\\0", "B\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("A\\0", "b\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("a\\0", "b\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("A\\0", "B\\0")'))
+
+    eq(-1, fn.luaeval('vim.stricmp("\\0a", "\\0B")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0A", "\\0b")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0a", "\\0b")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0A", "\\0B")'))
+
+    eq(-1, fn.luaeval('vim.stricmp("\\0a\\0", "\\0B\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0A\\0", "\\0b\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0a\\0", "\\0b\\0")'))
+    eq(-1, fn.luaeval('vim.stricmp("\\0A\\0", "\\0B\\0")'))
+
+    eq(1, fn.luaeval('vim.stricmp("c", "B")'))
+    eq(1, fn.luaeval('vim.stricmp("C", "b")'))
+    eq(1, fn.luaeval('vim.stricmp("c", "b")'))
+    eq(1, fn.luaeval('vim.stricmp("C", "B")'))
+
+    eq(1, fn.luaeval('vim.stricmp("\\0", "")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0", "\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0\\0", "\\0\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0\\0\\0", "\\0\\0\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0\\0C", "\\0\\0\\0b")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0\\0c", "\\0\\0\\0B")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0\\0\\0c", "\\0\\0\\0b")'))
+
+    eq(1, fn.luaeval('vim.stricmp("c\\0", "B\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("C\\0", "b\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("c\\0", "b\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("C\\0", "B\\0")'))
+
+    eq(1, fn.luaeval('vim.stricmp("c\\0", "B")'))
+    eq(1, fn.luaeval('vim.stricmp("C\\0", "b")'))
+    eq(1, fn.luaeval('vim.stricmp("c\\0", "b")'))
+    eq(1, fn.luaeval('vim.stricmp("C\\0", "B")'))
+
+    eq(1, fn.luaeval('vim.stricmp("\\0c", "\\0B")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0C", "\\0b")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0c", "\\0b")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0C", "\\0B")'))
+
+    eq(1, fn.luaeval('vim.stricmp("\\0c\\0", "\\0B\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0C\\0", "\\0b\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0c\\0", "\\0b\\0")'))
+    eq(1, fn.luaeval('vim.stricmp("\\0C\\0", "\\0B\\0")'))
   end)
 
-  it('vim.startswith', function()
-    eq(true, funcs.luaeval('vim.startswith("123", "1")'))
-    eq(true, funcs.luaeval('vim.startswith("123", "")'))
-    eq(true, funcs.luaeval('vim.startswith("123", "123")'))
-    eq(true, funcs.luaeval('vim.startswith("", "")'))
+  local function test_vim_deprecate(current_version)
+    -- vim.deprecate(name, alternative, version, plugin, backtrace)
+    -- See MAINTAIN.md for the soft/hard deprecation policy
 
-    eq(false, funcs.luaeval('vim.startswith("123", " ")'))
-    eq(false, funcs.luaeval('vim.startswith("123", "2")'))
-    eq(false, funcs.luaeval('vim.startswith("123", "1234")'))
+    describe(('vim.deprecate [current_version = %s]'):format(current_version), function()
+      before_each(function()
+        -- mock vim.version() behavior, should be pinned for consistent testing
+        exec_lua(
+          [[
+            local current_version_mock = vim.version.parse(...)
+            getmetatable(vim.version).__call = function()
+              return current_version_mock
+            end
+          ]],
+          current_version
+        )
+      end)
 
-    matches("prefix: expected string, got nil",
-      pcall_err(exec_lua, 'return vim.startswith("123", nil)'))
-    matches("s: expected string, got nil",
-      pcall_err(exec_lua, 'return vim.startswith(nil, "123")'))
-  end)
+      it('when plugin = nil', function()
+        eq(
+          dedent [[
+            foo.bar() is deprecated, use zub.wooo{ok=yay} instead. :help deprecated
+            This feature will be removed in Nvim version 0.10]],
+          exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', '0.10')
+        )
+        -- Same message, skipped.
+        eq(vim.NIL, exec_lua('return vim.deprecate(...)', 'foo.bar()', 'zub.wooo{ok=yay}', '0.10'))
+
+        -- Don't show error if not hard-deprecated (only soft-deprecated)
+        eq(
+          vim.NIL,
+          exec_lua('return vim.deprecate(...)', 'foo.baz()', 'foo.better_baz()', '0.12.0')
+        )
+
+        -- Show error if hard-deprecated
+        eq(
+          dedent [[
+            foo.hard_dep() is deprecated, use vim.new_api() instead. :help deprecated
+            This feature will be removed in Nvim version 0.11]],
+          exec_lua('return vim.deprecate(...)', 'foo.hard_dep()', 'vim.new_api()', '0.11')
+        )
+
+        -- To be deleted in the next major version (1.0)
+        eq(
+          dedent [[
+            foo.baz() is deprecated. :help deprecated
+            This feature will be removed in Nvim version 1.0]],
+          exec_lua [[ return vim.deprecate('foo.baz()', nil, '1.0') ]]
+        )
+      end)
 
-  it('vim.endswith', function()
-    eq(true, funcs.luaeval('vim.endswith("123", "3")'))
-    eq(true, funcs.luaeval('vim.endswith("123", "")'))
-    eq(true, funcs.luaeval('vim.endswith("123", "123")'))
-    eq(true, funcs.luaeval('vim.endswith("", "")'))
+      it('when plugin is specified', function()
+        -- When `plugin` is specified, don't show ":help deprecated". #22235
+        eq(
+          dedent [[
+            foo.bar() is deprecated, use zub.wooo{ok=yay} instead.
+            This feature will be removed in my-plugin.nvim version 0.3.0]],
+          exec_lua(
+            'return vim.deprecate(...)',
+            'foo.bar()',
+            'zub.wooo{ok=yay}',
+            '0.3.0',
+            'my-plugin.nvim',
+            false
+          )
+        )
+
+        -- plugins: no soft deprecation period
+        eq(
+          dedent [[
+            foo.bar() is deprecated, use zub.wooo{ok=yay} instead.
+            This feature will be removed in my-plugin.nvim version 0.11.0]],
+          exec_lua(
+            'return vim.deprecate(...)',
+            'foo.bar()',
+            'zub.wooo{ok=yay}',
+            '0.11.0',
+            'my-plugin.nvim',
+            false
+          )
+        )
+      end)
+    end)
+  end
 
-    eq(false, funcs.luaeval('vim.endswith("123", " ")'))
-    eq(false, funcs.luaeval('vim.endswith("123", "2")'))
-    eq(false, funcs.luaeval('vim.endswith("123", "1234")'))
+  test_vim_deprecate('0.10')
+  test_vim_deprecate('0.10-dev+g0000000')
 
-    matches("suffix: expected string, got nil",
-      pcall_err(exec_lua, 'return vim.endswith("123", nil)'))
-    matches("s: expected string, got nil",
-      pcall_err(exec_lua, 'return vim.endswith(nil, "123")'))
+  it('vim.startswith', function()
+    eq(true, fn.luaeval('vim.startswith("123", "1")'))
+    eq(true, fn.luaeval('vim.startswith("123", "")'))
+    eq(true, fn.luaeval('vim.startswith("123", "123")'))
+    eq(true, fn.luaeval('vim.startswith("", "")'))
+
+    eq(false, fn.luaeval('vim.startswith("123", " ")'))
+    eq(false, fn.luaeval('vim.startswith("123", "2")'))
+    eq(false, fn.luaeval('vim.startswith("123", "1234")'))
+
+    matches(
+      'prefix: expected string, got nil',
+      pcall_err(exec_lua, 'return vim.startswith("123", nil)')
+    )
+    matches('s: expected string, got nil', pcall_err(exec_lua, 'return vim.startswith(nil, "123")'))
+  end)
+
+  it('vim.endswith', function()
+    eq(true, fn.luaeval('vim.endswith("123", "3")'))
+    eq(true, fn.luaeval('vim.endswith("123", "")'))
+    eq(true, fn.luaeval('vim.endswith("123", "123")'))
+    eq(true, fn.luaeval('vim.endswith("", "")'))
+
+    eq(false, fn.luaeval('vim.endswith("123", " ")'))
+    eq(false, fn.luaeval('vim.endswith("123", "2")'))
+    eq(false, fn.luaeval('vim.endswith("123", "1234")'))
+
+    matches(
+      'suffix: expected string, got nil',
+      pcall_err(exec_lua, 'return vim.endswith("123", nil)')
+    )
+    matches('s: expected string, got nil', pcall_err(exec_lua, 'return vim.endswith(nil, "123")'))
   end)
 
-  it("vim.str_utfindex/str_byteindex", function()
+  it('vim.str_utfindex/str_byteindex', function()
     exec_lua([[_G.test_text = "xy åäö ɧ 汉语 ↥ 🤦x🦄 å بِيَّ\000ъ"]])
-    local indices32 = {[0]=0,1,2,3,5,7,9,10,12,13,16,19,20,23,24,28,29,33,34,35,37,38,40,42,44,46,48,49,51}
-    local indices16 = {[0]=0,1,2,3,5,7,9,10,12,13,16,19,20,23,24,28,28,29,33,33,34,35,37,38,40,42,44,46,48,49,51}
-    for i,k in pairs(indices32) do
-      eq(k, exec_lua("return vim.str_byteindex(_G.test_text, ...)", i), i)
+    local indices32 = {
+      [0] = 0,
+      1,
+      2,
+      3,
+      5,
+      7,
+      9,
+      10,
+      12,
+      13,
+      16,
+      19,
+      20,
+      23,
+      24,
+      28,
+      29,
+      33,
+      34,
+      35,
+      37,
+      38,
+      40,
+      42,
+      44,
+      46,
+      48,
+      49,
+      51,
+    }
+    local indices16 = {
+      [0] = 0,
+      1,
+      2,
+      3,
+      5,
+      7,
+      9,
+      10,
+      12,
+      13,
+      16,
+      19,
+      20,
+      23,
+      24,
+      28,
+      28,
+      29,
+      33,
+      33,
+      34,
+      35,
+      37,
+      38,
+      40,
+      42,
+      44,
+      46,
+      48,
+      49,
+      51,
+    }
+    for i, k in pairs(indices32) do
+      eq(k, exec_lua('return vim.str_byteindex(_G.test_text, ...)', i), i)
     end
-    for i,k in pairs(indices16) do
-      eq(k, exec_lua("return vim.str_byteindex(_G.test_text, ..., true)", i), i)
+    for i, k in pairs(indices16) do
+      eq(k, exec_lua('return vim.str_byteindex(_G.test_text, ..., true)', i), i)
     end
-    eq("index out of range", pcall_err(exec_lua, "return vim.str_byteindex(_G.test_text, ...)", #indices32 + 1))
-    eq("index out of range", pcall_err(exec_lua, "return vim.str_byteindex(_G.test_text, ..., true)", #indices16 + 1))
+    eq(
+      'index out of range',
+      pcall_err(exec_lua, 'return vim.str_byteindex(_G.test_text, ...)', #indices32 + 1)
+    )
+    eq(
+      'index out of range',
+      pcall_err(exec_lua, 'return vim.str_byteindex(_G.test_text, ..., true)', #indices16 + 1)
+    )
     local i32, i16 = 0, 0
     local len = 51
-    for k = 0,len do
+    for k = 0, len do
       if indices32[i32] < k then
         i32 = i32 + 1
       end
       if indices16[i16] < k then
         i16 = i16 + 1
-        if indices16[i16+1] == indices16[i16] then
+        if indices16[i16 + 1] == indices16[i16] then
           i16 = i16 + 1
         end
       end
-      eq({i32, i16}, exec_lua("return {vim.str_utfindex(_G.test_text, ...)}", k), k)
+      eq({ i32, i16 }, exec_lua('return {vim.str_utfindex(_G.test_text, ...)}', k), k)
     end
-    eq("index out of range", pcall_err(exec_lua, "return vim.str_utfindex(_G.test_text, ...)", len + 1))
+    eq(
+      'index out of range',
+      pcall_err(exec_lua, 'return vim.str_utfindex(_G.test_text, ...)', len + 1)
+    )
   end)
 
-  it("vim.str_utf_start", function()
+  it('vim.str_utf_start', function()
     exec_lua([[_G.test_text = "xy åäö ɧ 汉语 ↥ 🤦x🦄 å بِيَّ"]])
-    local expected_positions = {0,0,0,0,-1,0,-1,0,-1,0,0,-1,0,0,-1,-2,0,-1,-2,0,0,-1,-2,0,0,-1,-2,-3,0,0,-1,-2,-3,0,0,0,-1,0,0,-1,0,-1,0,-1,0,-1,0,-1}
-    eq(expected_positions, exec_lua([[
+    local expected_positions = {
+      0,
+      0,
+      0,
+      0,
+      -1,
+      0,
+      -1,
+      0,
+      -1,
+      0,
+      0,
+      -1,
+      0,
+      0,
+      -1,
+      -2,
+      0,
+      -1,
+      -2,
+      0,
+      0,
+      -1,
+      -2,
+      0,
+      0,
+      -1,
+      -2,
+      -3,
+      0,
+      0,
+      -1,
+      -2,
+      -3,
+      0,
+      0,
+      0,
+      -1,
+      0,
+      0,
+      -1,
+      0,
+      -1,
+      0,
+      -1,
+      0,
+      -1,
+      0,
+      -1,
+    }
+    eq(
+      expected_positions,
+      exec_lua([[
       local start_codepoint_positions = {}
       for idx = 1, #_G.test_text do
         table.insert(start_codepoint_positions, vim.str_utf_start(_G.test_text, idx))
       end
       return start_codepoint_positions
-    ]]))
+    ]])
+    )
   end)
 
-  it("vim.str_utf_end", function()
+  it('vim.str_utf_end', function()
     exec_lua([[_G.test_text = "xy åäö ɧ 汉语 ↥ 🤦x🦄 å بِيَّ"]])
-    local expected_positions = {0,0,0,1,0,1,0,1,0,0,1,0,0,2,1,0,2,1,0,0,2,1,0,0,3,2,1,0,0,3,2,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0 }
-    eq(expected_positions, exec_lua([[
+    local expected_positions = {
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      2,
+      1,
+      0,
+      2,
+      1,
+      0,
+      0,
+      2,
+      1,
+      0,
+      0,
+      3,
+      2,
+      1,
+      0,
+      0,
+      3,
+      2,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+    }
+    eq(
+      expected_positions,
+      exec_lua([[
       local end_codepoint_positions = {}
       for idx = 1, #_G.test_text do
         table.insert(end_codepoint_positions, vim.str_utf_end(_G.test_text, idx))
       end
       return end_codepoint_positions
-    ]]))
+    ]])
+    )
   end)
 
-
-  it("vim.str_utf_pos", function()
+  it('vim.str_utf_pos', function()
     exec_lua([[_G.test_text = "xy åäö ɧ 汉语 ↥ 🤦x🦄 å بِيَّ"]])
-    local expected_positions = { 1,2,3,4,6,8,10,11,13,14,17,20,21,24,25,29,30,34,35,36,38,39,41,43,45,47 }
-    eq(expected_positions, exec_lua("return vim.str_utf_pos(_G.test_text)"))
+    local expected_positions = {
+      1,
+      2,
+      3,
+      4,
+      6,
+      8,
+      10,
+      11,
+      13,
+      14,
+      17,
+      20,
+      21,
+      24,
+      25,
+      29,
+      30,
+      34,
+      35,
+      36,
+      38,
+      39,
+      41,
+      43,
+      45,
+      47,
+    }
+    eq(expected_positions, exec_lua('return vim.str_utf_pos(_G.test_text)'))
   end)
 
-  it("vim.schedule", function()
+  it('vim.schedule', function()
     exec_lua([[
       test_table = {}
       vim.schedule(function()
@@ -244,13 +519,11 @@ describe('lua stdlib', function()
       end)
       table.insert(test_table, "yy")
     ]])
-    eq({"yy","xx"}, exec_lua("return test_table"))
+    eq({ 'yy', 'xx' }, exec_lua('return test_table'))
 
     -- Validates args.
-    matches('vim.schedule: expected function',
-      pcall_err(exec_lua, "vim.schedule('stringly')"))
-    matches('vim.schedule: expected function',
-      pcall_err(exec_lua, "vim.schedule()"))
+    matches('vim.schedule: expected function', pcall_err(exec_lua, "vim.schedule('stringly')"))
+    matches('vim.schedule: expected function', pcall_err(exec_lua, 'vim.schedule()'))
 
     exec_lua([[
       vim.schedule(function()
@@ -258,24 +531,24 @@ describe('lua stdlib', function()
       end)
     ]])
 
-    feed("<cr>")
-    matches('big failure\nvery async', remove_trace(eval("v:errmsg")))
+    feed('<cr>')
+    matches('big failure\nvery async', remove_trace(eval('v:errmsg')))
 
-    local screen = Screen.new(60,5)
+    local screen = Screen.new(60, 5)
     screen:set_default_attr_ids({
-      [1] = {bold = true, foreground = Screen.colors.Blue1},
-      [2] = {bold = true, reverse = true},
-      [3] = {foreground = Screen.colors.Grey100, background = Screen.colors.Red},
-      [4] = {bold = true, foreground = Screen.colors.SeaGreen4},
+      [1] = { bold = true, foreground = Screen.colors.Blue1 },
+      [2] = { bold = true, reverse = true },
+      [3] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
+      [4] = { bold = true, foreground = Screen.colors.SeaGreen4 },
     })
     screen:attach()
-    screen:expect{grid=[[
+    screen:expect {
+      grid = [[
       ^                                                            |
-      {1:~                                                           }|
-      {1:~                                                           }|
-      {1:~                                                           }|
+      {1:~                                                           }|*3
                                                                   |
-    ]]}
+    ]],
+    }
 
     -- nvim_command causes a Vimscript exception, check that it is properly caught
     -- and propagated as an error message in async contexts.. #10809
@@ -284,62 +557,61 @@ describe('lua stdlib', function()
         vim.api.nvim_command(":echo 'err")
       end)
     ]])
-    screen:expect{grid=[[
+    screen:expect {
+      grid = [[
       {3:stack traceback:}                                            |
       {3:        [C]: in function 'nvim_command'}                     |
       {3:        [string "<nvim>"]:2: in function <[string "<nvim>"]:}|
       {3:1>}                                                          |
       {4:Press ENTER or type command to continue}^                     |
-    ]]}
+    ]],
+    }
   end)
 
   it('vim.gsplit, vim.split', function()
     local tests = {
       --                            plain  trimempty
-      { 'a,b',             ',',     false, false, { 'a', 'b' } },
-      { ':aa::::bb:',      ':',     false, false, { '', 'aa', '', '', '', 'bb', '' } },
-      { ':aa::::bb:',      ':',     false, true,  { 'aa', '', '', '', 'bb' } },
-      { 'aa::::bb:',       ':',     false, true,  { 'aa', '', '', '', 'bb' } },
-      { ':aa::bb:',        ':',     false, true,  { 'aa', '', 'bb' } },
-      { '/a/b:/b/\n',      '[:\n]', false, true,  { '/a/b', '/b/' } },
-      { '::ee::ff:',       ':',     false, false, { '', '', 'ee', '', 'ff', '' } },
-      { '::ee::ff::',      ':',     false, true,  { 'ee', '', 'ff' } },
-      { 'ab',              '.',     false, false, { '', '', '' } },
-      { 'a1b2c',           '[0-9]', false, false, { 'a', 'b', 'c' } },
-      { 'xy',              '',      false, false, { 'x', 'y' } },
-      { 'here be dragons', ' ',     false, false, { 'here', 'be', 'dragons'} },
-      { 'axaby',           'ab?',   false, false, { '', 'x', 'y' } },
-      { 'f v2v v3v w2w ',  '([vw])2%1', false, false, { 'f ', ' v3v ', ' ' } },
-      { '',                '',      false, false, {} },
-      { '',                '',      false, true,  {} },
-      { '\n',              '[:\n]', false, true,  {} },
-      { '',                'a',     false, false, { '' } },
-      { 'x*yz*oo*l',       '*',     true,  false, { 'x', 'yz', 'oo', 'l' } },
+      { 'a,b', ',', false, false, { 'a', 'b' } },
+      { ':aa::::bb:', ':', false, false, { '', 'aa', '', '', '', 'bb', '' } },
+      { ':aa::::bb:', ':', false, true, { 'aa', '', '', '', 'bb' } },
+      { 'aa::::bb:', ':', false, true, { 'aa', '', '', '', 'bb' } },
+      { ':aa::bb:', ':', false, true, { 'aa', '', 'bb' } },
+      { '/a/b:/b/\n', '[:\n]', false, true, { '/a/b', '/b/' } },
+      { '::ee::ff:', ':', false, false, { '', '', 'ee', '', 'ff', '' } },
+      { '::ee::ff::', ':', false, true, { 'ee', '', 'ff' } },
+      { 'ab', '.', false, false, { '', '', '' } },
+      { 'a1b2c', '[0-9]', false, false, { 'a', 'b', 'c' } },
+      { 'xy', '', false, false, { 'x', 'y' } },
+      { 'here be dragons', ' ', false, false, { 'here', 'be', 'dragons' } },
+      { 'axaby', 'ab?', false, false, { '', 'x', 'y' } },
+      { 'f v2v v3v w2w ', '([vw])2%1', false, false, { 'f ', ' v3v ', ' ' } },
+      { '', '', false, false, {} },
+      { '', '', false, true, {} },
+      { '\n', '[:\n]', false, true, {} },
+      { '', 'a', false, false, { '' } },
+      { 'x*yz*oo*l', '*', true, false, { 'x', 'yz', 'oo', 'l' } },
     }
 
     for _, t in ipairs(tests) do
-      eq(t[5], vim.split(t[1], t[2], {plain=t[3], trimempty=t[4]}), t[1])
+      eq(t[5], vim.split(t[1], t[2], { plain = t[3], trimempty = t[4] }), t[1])
     end
 
     -- Test old signature
-    eq({'x', 'yz', 'oo', 'l'}, vim.split("x*yz*oo*l", "*", true))
+    eq({ 'x', 'yz', 'oo', 'l' }, vim.split('x*yz*oo*l', '*', true))
 
     local loops = {
-      { "abc", ".-" },
+      { 'abc', '.-' },
     }
 
     for _, t in ipairs(loops) do
-      matches("Infinite loop detected", pcall_err(vim.split, t[1], t[2]))
+      matches('Infinite loop detected', pcall_err(vim.split, t[1], t[2]))
     end
 
     -- Validates args.
     eq(true, pcall(vim.split, 'string', 'string'))
-    matches('s: expected string, got number',
-      pcall_err(vim.split, 1, 'string'))
-    matches('sep: expected string, got number',
-      pcall_err(vim.split, 'string', 1))
-    matches('opts: expected table, got number',
-      pcall_err(vim.split, 'string', 'string', 1))
+    matches('s: expected string, got number', pcall_err(vim.split, 1, 'string'))
+    matches('sep: expected string, got number', pcall_err(vim.split, 'string', 1))
+    matches('opts: expected table, got number', pcall_err(vim.split, 'string', 'string', 1))
   end)
 
   it('vim.trim', function()
@@ -348,10 +620,10 @@ describe('lua stdlib', function()
     end
 
     local trims = {
-      { "   a", "a" },
-      { " b  ", "b" },
-      { "\tc" , "c" },
-      { "r\n", "r" },
+      { '   a', 'a' },
+      { ' b  ', 'b' },
+      { '\tc', 'c' },
+      { 'r\n', 'r' },
     }
 
     for _, t in ipairs(trims) do
@@ -359,8 +631,7 @@ describe('lua stdlib', function()
     end
 
     -- Validates args.
-    matches('s: expected string, got number',
-      pcall_err(trim, 2))
+    matches('s: expected string, got number', pcall_err(trim, 2))
   end)
 
   it('vim.inspect', function()
@@ -370,21 +641,23 @@ describe('lua stdlib', function()
     end
 
     eq('2', inspect(2))
-    eq('{+a = {+b = 1+}+}',
-       inspect({ a = { b = 1 } }, { newline = '+', indent = '' }))
+    eq('{+a = {+b = 1+}+}', inspect({ a = { b = 1 } }, { newline = '+', indent = '' }))
 
     -- special value vim.inspect.KEY works
-    eq('{  KEY_a = "x",  KEY_b = "y"}', exec_lua([[
+    eq(
+      '{  KEY_a = "x",  KEY_b = "y"}',
+      exec_lua([[
       return vim.inspect({a="x", b="y"}, {newline = '', process = function(item, path)
         if path[#path] == vim.inspect.KEY then
           return 'KEY_'..item
         end
         return item
       end})
-    ]]))
+    ]])
+    )
   end)
 
-  it("vim.deepcopy", function()
+  it('vim.deepcopy', function()
     ok(exec_lua([[
       local a = { x = { 1, 2 }, y = 5}
       local b = vim.deepcopy(a)
@@ -445,23 +718,27 @@ describe('lua stdlib', function()
       return t2.a == vim.NIL
     ]]))
 
-    matches('Cannot deepcopy object of type thread',
-      pcall_err(exec_lua, [[
+    matches(
+      'Cannot deepcopy object of type thread',
+      pcall_err(
+        exec_lua,
+        [[
         local thread = coroutine.create(function () return 0 end)
         local t = {thr = thread}
         vim.deepcopy(t)
-      ]]))
+      ]]
+      )
+    )
   end)
 
   it('vim.pesc', function()
     eq('foo%-bar', exec_lua([[return vim.pesc('foo-bar')]]))
     eq('foo%%%-bar', exec_lua([[return vim.pesc(vim.pesc('foo-bar'))]]))
     -- pesc() returns one result. #20751
-    eq({'x'}, exec_lua([[return {vim.pesc('x')}]]))
+    eq({ 'x' }, exec_lua([[return {vim.pesc('x')}]]))
 
     -- Validates args.
-    matches('s: expected string, got number',
-      pcall_err(exec_lua, [[return vim.pesc(2)]]))
+    matches('s: expected string, got number', pcall_err(exec_lua, [[return vim.pesc(2)]]))
   end)
 
   it('vim.list_contains', function()
@@ -473,97 +750,131 @@ describe('lua stdlib', function()
     eq(true, exec_lua("return vim.tbl_contains({'a','b','c'}, 'c')"))
     eq(false, exec_lua("return vim.tbl_contains({'a','b','c'}, 'd')"))
     eq(true, exec_lua("return vim.tbl_contains({[2]='a',foo='b',[5] = 'c'}, 'c')"))
-    eq(true, exec_lua([[
+    eq(
+      true,
+      exec_lua([[
         return vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
           return vim.deep_equal(v, { 'b', 'c' })
         end, { predicate = true })
-    ]]))
+    ]])
+    )
   end)
 
   it('vim.tbl_keys', function()
-    eq({}, exec_lua("return vim.tbl_keys({})"))
+    eq({}, exec_lua('return vim.tbl_keys({})'))
     for _, v in pairs(exec_lua("return vim.tbl_keys({'a', 'b', 'c'})")) do
-      eq(true, exec_lua("return vim.tbl_contains({ 1, 2, 3 }, ...)", v))
+      eq(true, exec_lua('return vim.tbl_contains({ 1, 2, 3 }, ...)', v))
     end
-    for _, v in pairs(exec_lua("return vim.tbl_keys({a=1, b=2, c=3})")) do
+    for _, v in pairs(exec_lua('return vim.tbl_keys({a=1, b=2, c=3})')) do
       eq(true, exec_lua("return vim.tbl_contains({ 'a', 'b', 'c' }, ...)", v))
     end
   end)
 
   it('vim.tbl_values', function()
-    eq({}, exec_lua("return vim.tbl_values({})"))
+    eq({}, exec_lua('return vim.tbl_values({})'))
     for _, v in pairs(exec_lua("return vim.tbl_values({'a', 'b', 'c'})")) do
       eq(true, exec_lua("return vim.tbl_contains({ 'a', 'b', 'c' }, ...)", v))
     end
-    for _, v in pairs(exec_lua("return vim.tbl_values({a=1, b=2, c=3})")) do
-      eq(true, exec_lua("return vim.tbl_contains({ 1, 2, 3 }, ...)", v))
+    for _, v in pairs(exec_lua('return vim.tbl_values({a=1, b=2, c=3})')) do
+      eq(true, exec_lua('return vim.tbl_contains({ 1, 2, 3 }, ...)', v))
     end
   end)
 
   it('vim.tbl_map', function()
-    eq({}, exec_lua([[
+    eq(
+      {},
+      exec_lua([[
       return vim.tbl_map(function(v) return v * 2 end, {})
-    ]]))
-    eq({2, 4, 6}, exec_lua([[
+    ]])
+    )
+    eq(
+      { 2, 4, 6 },
+      exec_lua([[
       return vim.tbl_map(function(v) return v * 2 end, {1, 2, 3})
-    ]]))
-    eq({{i=2}, {i=4}, {i=6}}, exec_lua([[
+    ]])
+    )
+    eq(
+      { { i = 2 }, { i = 4 }, { i = 6 } },
+      exec_lua([[
       return vim.tbl_map(function(v) return { i = v.i * 2 } end, {{i=1}, {i=2}, {i=3}})
-    ]]))
+    ]])
+    )
   end)
 
   it('vim.tbl_filter', function()
-    eq({}, exec_lua([[
+    eq(
+      {},
+      exec_lua([[
       return vim.tbl_filter(function(v) return (v % 2) == 0 end, {})
-    ]]))
-    eq({2}, exec_lua([[
+    ]])
+    )
+    eq(
+      { 2 },
+      exec_lua([[
       return vim.tbl_filter(function(v) return (v % 2) == 0 end, {1, 2, 3})
-    ]]))
-    eq({{i=2}}, exec_lua([[
+    ]])
+    )
+    eq(
+      { { i = 2 } },
+      exec_lua([[
       return vim.tbl_filter(function(v) return (v.i % 2) == 0 end, {{i=1}, {i=2}, {i=3}})
-    ]]))
+    ]])
+    )
   end)
 
   it('vim.tbl_isarray', function()
-    eq(true, exec_lua("return vim.tbl_isarray({})"))
-    eq(false, exec_lua("return vim.tbl_isarray(vim.empty_dict())"))