15 files changed, 917 insertions, 106 deletions
diff --git a/test/functional/lua/diagnostic_spec.lua b/test/functional/lua/diagnostic_spec.lua
index eb1ac3e6a1..a19f558ef2 100644
--- a/test/functional/lua/diagnostic_spec.lua
+++ b/test/functional/lua/diagnostic_spec.lua
@@ -5,6 +5,7 @@ local command = n.command
 local clear = n.clear
 local exec_lua = n.exec_lua
 local eq = t.eq
+local neq = t.neq
 local matches = t.matches
 local api = n.api
 local pcall_err = t.pcall_err
@@ -112,6 +113,18 @@ describe('vim.diagnostic', function()
         )
       end
 
+      function _G.get_virt_lines_extmarks(ns)
+        ns = vim.diagnostic.get_namespace(ns)
+        local virt_lines_ns = ns.user_data.virt_lines_ns
+        return vim.api.nvim_buf_get_extmarks(
+          _G.diagnostic_bufnr,
+          virt_lines_ns,
+          0,
+          -1,
+          { details = true }
+        )
+      end
+
       ---@param ns integer
       function _G.get_underline_extmarks(ns)
         ---@type integer
@@ -160,6 +173,11 @@ describe('vim.diagnostic', function()
       'DiagnosticUnderlineOk',
       'DiagnosticUnderlineWarn',
       'DiagnosticUnnecessary',
+      'DiagnosticVirtualLinesError',
+      'DiagnosticVirtualLinesHint',
+      'DiagnosticVirtualLinesInfo',
+      'DiagnosticVirtualLinesOk',
+      'DiagnosticVirtualLinesWarn',
       'DiagnosticVirtualTextError',
       'DiagnosticVirtualTextHint',
       'DiagnosticVirtualTextInfo',
@@ -368,6 +386,9 @@ describe('vim.diagnostic', function()
   end)
 
   it('handles one namespace clearing highlights while the other still has highlights', function()
+    exec_lua(function()
+      vim.diagnostic.config({ virtual_text = true })
+    end)
     -- 1 Error (1)
     -- 1 Warning (2)
     -- 1 Warning (2) + 1 Warning (1)
@@ -442,6 +463,10 @@ describe('vim.diagnostic', function()
   end)
 
   it('does not display diagnostics when disabled', function()
+    exec_lua(function()
+      vim.diagnostic.config({ virtual_text = true })
+    end)
+
     eq(
       { 0, 2 },
       exec_lua(function()
@@ -574,7 +599,7 @@ describe('vim.diagnostic', function()
         vim.diagnostic.set(
           _G.diagnostic_ns,
           _G.diagnostic_bufnr,
-          { { lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
+          { { message = '', lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
         )
         vim.cmd('bwipeout! ' .. _G.diagnostic_bufnr)
 
@@ -915,6 +940,10 @@ describe('vim.diagnostic', function()
 
   describe('reset()', function()
     it('diagnostic count is 0 and displayed diagnostics are 0 after call', function()
+      exec_lua(function()
+        vim.diagnostic.config({ virtual_text = true })
+      end)
+
       -- 1 Error (1)
       -- 1 Warning (2)
       -- 1 Warning (2) + 1 Warning (1)
@@ -1005,7 +1034,7 @@ describe('vim.diagnostic', function()
         vim.diagnostic.set(
           _G.diagnostic_ns,
           _G.diagnostic_bufnr,
-          { { lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
+          { { message = '', lnum = 0, end_lnum = 0, col = 0, end_col = 0 } }
         )
         vim.cmd('bwipeout! ' .. _G.diagnostic_bufnr)
 
@@ -2105,6 +2134,139 @@ describe('vim.diagnostic', function()
         end)
       )
     end)
+
+    it('can filter diagnostics by returning nil when formatting', function()
+      local result = exec_lua(function()
+        vim.diagnostic.config {
+          virtual_text = {
+            format = function(diagnostic)
+              if diagnostic.code == 'foo_err' then
+                return nil
+              end
+              return diagnostic.message
+            end,
+          },
+        }
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('An error here!', 0, 0, 0, 0, 'foo_server', 'foo_err'),
+          _G.make_error('An error there!', 1, 1, 1, 1, 'bar_server', 'bar_err'),
+        })
+
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+        return extmarks
+      end)
+
+      eq(1, #result)
+      eq(' An error there!', result[1][4].virt_text[3][1])
+    end)
+
+    it('can only show virtual_text for the current line', function()
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_cursor(0, { 1, 0 })
+
+        vim.diagnostic.config({ virtual_text = { current_line = true } })
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error here!', 0, 0, 0, 0, 'foo_server'),
+          _G.make_error('Another error there!', 1, 0, 1, 0, 'foo_server'),
+        })
+
+        local extmarks = _G.get_virt_text_extmarks(_G.diagnostic_ns)
+        return extmarks
+      end)
+
+      eq(1, #result)
+      eq(' Error here!', result[1][4].virt_text[3][1])
+    end)
+  end)
+
+  describe('handlers.virtual_lines', function()
+    it('includes diagnostic code and message', function()
+      local result = exec_lua(function()
+        vim.diagnostic.config({ virtual_lines = true })
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Missed symbol `,`', 0, 0, 0, 0, 'lua_ls', 'miss-symbol'),
+        })
+
+        local extmarks = _G.get_virt_lines_extmarks(_G.diagnostic_ns)
+        return extmarks[1][4].virt_lines
+      end)
+
+      eq('miss-symbol: Missed symbol `,`', result[1][3][1])
+    end)
+
+    it('adds space to the left of the diagnostic', function()
+      local error_offset = 5
+      local result = exec_lua(function()
+        vim.diagnostic.config({ virtual_lines = true })
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error here!', 0, error_offset, 0, error_offset, 'foo_server'),
+        })
+
+        local extmarks = _G.get_virt_lines_extmarks(_G.diagnostic_ns)
+        return extmarks[1][4].virt_lines
+      end)
+
+      eq(error_offset, result[1][1][1]:len())
+    end)
+
+    it('highlights diagnostics in multiple lines by default', function()
+      local result = exec_lua(function()
+        vim.diagnostic.config({ virtual_lines = true })
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error here!', 0, 0, 0, 0, 'foo_server'),
+          _G.make_error('Another error there!', 1, 0, 1, 0, 'foo_server'),
+        })
+
+        local extmarks = _G.get_virt_lines_extmarks(_G.diagnostic_ns)
+        return extmarks
+      end)
+
+      eq(2, #result)
+      eq('Error here!', result[1][4].virt_lines[1][3][1])
+      eq('Another error there!', result[2][4].virt_lines[1][3][1])
+    end)
+
+    it('can highlight diagnostics only in the current line', function()
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_cursor(0, { 1, 0 })
+
+        vim.diagnostic.config({ virtual_lines = { current_line = true } })
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error here!', 0, 0, 0, 0, 'foo_server'),
+          _G.make_error('Another error there!', 1, 0, 1, 0, 'foo_server'),
+        })
+
+        local extmarks = _G.get_virt_lines_extmarks(_G.diagnostic_ns)
+        return extmarks
+      end)
+
+      eq(1, #result)
+      eq('Error here!', result[1][4].virt_lines[1][3][1])
+    end)
+
+    it('supports a format function for diagnostic messages', function()
+      local result = exec_lua(function()
+        vim.diagnostic.config({
+          virtual_lines = {
+            format = function()
+              return 'Error here!'
+            end,
+          },
+        })
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Invalid syntax', 0, 0, 0, 0),
+        })
+        local extmarks = _G.get_virt_lines_extmarks(_G.diagnostic_ns)
+        return extmarks[1][4].virt_lines
+      end)
+      eq('Error here!', result[1][3][1])
+    end)
   end)
 
   describe('set()', function()
@@ -2116,7 +2278,11 @@ describe('vim.diagnostic', function()
     end)
 
     it('can perform updates after insert_leave', function()
-      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
+      exec_lua(function()
+        vim.diagnostic.config({ virtual_text = true })
+        vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+      end)
+
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
@@ -2257,7 +2423,10 @@ describe('vim.diagnostic', function()
     end)
 
     it('can perform updates while in insert mode, if desired', function()
-      exec_lua [[vim.api.nvim_set_current_buf( _G.diagnostic_bufnr)]]
+      exec_lua(function()
+        vim.diagnostic.config({ virtual_text = true })
+        vim.api.nvim_set_current_buf(_G.diagnostic_bufnr)
+      end)
       api.nvim_input('o')
       eq({ mode = 'i', blocking = false }, api.nvim_get_mode())
 
@@ -2291,6 +2460,10 @@ describe('vim.diagnostic', function()
     end)
 
     it('can set diagnostics without displaying them', function()
+      exec_lua(function()
+        vim.diagnostic.config({ virtual_text = true })
+      end)
+
       eq(
         0,
         exec_lua(function()
@@ -3212,6 +3385,74 @@ describe('vim.diagnostic', function()
     end)
   end)
 
+  describe('setqflist()', function()
+    it('updates existing diagnostics quickfix if one already exists', function()
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+
+        vim.fn.setqflist({}, ' ', { title = 'Diagnostics' })
+        local diagnostics_qf_id = vim.fn.getqflist({ id = 0 }).id
+
+        vim.diagnostic.setqflist({ title = 'Diagnostics' })
+        local qf_id = vim.fn.getqflist({ id = 0, nr = '$' }).id
+
+        return { diagnostics_qf_id, qf_id }
+      end)
+
+      eq(result[1], result[2])
+    end)
+
+    it('navigates to existing diagnostics quickfix if one already exists and open=true', function()
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+
+        vim.fn.setqflist({}, ' ', { title = 'Diagnostics' })
+        local diagnostics_qf_id = vim.fn.getqflist({ id = 0 }).id
+
+        vim.fn.setqflist({}, ' ', { title = 'Other' })
+
+        vim.diagnostic.setqflist({ title = 'Diagnostics', open = true })
+        local qf_id = vim.fn.getqflist({ id = 0 }).id
+
+        return { diagnostics_qf_id, qf_id }
+      end)
+
+      eq(result[1], result[2])
+    end)
+
+    it('sets new diagnostics quickfix as active when open=true', function()
+      local result = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+
+        vim.fn.setqflist({}, ' ', { title = 'Other' })
+        local other_qf_id = vim.fn.getqflist({ id = 0 }).id
+
+        vim.diagnostic.setqflist({ title = 'Diagnostics', open = true })
+        local qf_id = vim.fn.getqflist({ id = 0 }).id
+
+        return { other_qf_id, qf_id }
+      end)
+
+      neq(result[1], result[2])
+    end)
+
+    it('opens quickfix window when open=true', function()
+      local qf_winid = exec_lua(function()
+        vim.api.nvim_win_set_buf(0, _G.diagnostic_bufnr)
+
+        vim.diagnostic.set(_G.diagnostic_ns, _G.diagnostic_bufnr, {
+          _G.make_error('Error', 1, 1, 1, 1),
+        })
+
+        vim.diagnostic.setqflist({ open = true })
+
+        return vim.fn.getqflist({ winid = 0 }).winid
+      end)
+
+      neq(0, qf_winid)
+    end)
+  end)
+
   describe('match()', function()
     it('matches a string', function()
       local msg = 'ERROR: george.txt:19:84:Two plus two equals five'
diff --git a/test/functional/lua/filetype_spec.lua b/test/functional/lua/filetype_spec.lua
index b6011d5268..b75ff75b05 100644
--- a/test/functional/lua/filetype_spec.lua
+++ b/test/functional/lua/filetype_spec.lua
@@ -199,7 +199,19 @@ describe('filetype.lua', function()
     finally(function()
       uv.fs_unlink('Xfiletype/.config/git')
     end)
-    clear({ args = { '--clean', 'Xfiletype/.config/git/config' } })
+    local args = { '--clean', 'Xfiletype/.config/git/config' }
+    clear({ args = args })
     eq('gitconfig', api.nvim_get_option_value('filetype', {}))
+    table.insert(args, 2, '--cmd')
+    table.insert(args, 3, "autocmd BufRead * call expand('<afile>')")
+    clear({ args = args })
+    eq('gitconfig', api.nvim_get_option_value('filetype', {}))
+  end)
+
+  it('works with :doautocmd BufRead #31306', function()
+    clear({ args = { '--clean' } })
+    eq('', api.nvim_get_option_value('filetype', {}))
+    command('doautocmd BufRead README.md')
+    eq('markdown', api.nvim_get_option_value('filetype', {}))
   end)
 end)
diff --git a/test/functional/lua/fs_spec.lua b/test/functional/lua/fs_spec.lua
index f0d49205e7..33af25f629 100644
--- a/test/functional/lua/fs_spec.lua
+++ b/test/functional/lua/fs_spec.lua
@@ -17,6 +17,8 @@ local mkdir = t.mkdir
 
 local nvim_prog_basename = is_os('win') and 'nvim.exe' or 'nvim'
 
+local link_limit = is_os('win') and 64 or (is_os('mac') or is_os('bsd')) and 33 or 41
+
 local test_basename_dirname_eq = {
   '~/foo/',
   '~/foo',
@@ -152,7 +154,7 @@ describe('vim.fs', function()
       )
     end)
 
-    it('works with opts.depth and opts.skip', function()
+    it('works with opts.depth, opts.skip and opts.follow', function()
       io.open('testd/a1', 'w'):close()
       io.open('testd/b1', 'w'):close()
       io.open('testd/c1', 'w'):close()
@@ -166,10 +168,10 @@ describe('vim.fs', function()
       io.open('testd/a/b/c/b4', 'w'):close()
       io.open('testd/a/b/c/c4', 'w'):close()
 
-      local function run(dir, depth, skip)
-        return exec_lua(function()
-          local r = {}
-          local skip_f
+      local function run(dir, depth, skip, follow)
+        return exec_lua(function(follow_)
+          local r = {} --- @type table<string, string>
+          local skip_f --- @type function
           if skip then
             skip_f = function(n0)
               if vim.tbl_contains(skip or {}, n0) then
@@ -177,11 +179,11 @@ describe('vim.fs', function()
               end
             end
           end
-          for name, type_ in vim.fs.dir(dir, { depth = depth, skip = skip_f }) do
+          for name, type_ in vim.fs.dir(dir, { depth = depth, skip = skip_f, follow = follow_ }) do
             r[name] = type_
           end
           return r
-        end)
+        end, follow)
       end
 
       local exp = {}
@@ -197,6 +199,7 @@ describe('vim.fs', function()
       exp['a/b2'] = 'file'
       exp['a/c2'] = 'file'
       exp['a/b'] = 'directory'
+      local lexp = vim.deepcopy(exp)
 
       eq(exp, run('testd', 2))
 
@@ -213,6 +216,29 @@ describe('vim.fs', function()
       exp['a/b/c/c4'] = 'file'
 
       eq(exp, run('testd', 999))
+
+      vim.uv.fs_symlink(vim.uv.fs_realpath('testd/a'), 'testd/l', { junction = true, dir = true })
+      lexp['l'] = 'link'
+      eq(lexp, run('testd', 2, nil, false))
+
+      lexp['l/a2'] = 'file'
+      lexp['l/b2'] = 'file'
+      lexp['l/c2'] = 'file'
+      lexp['l/b'] = 'directory'
+      eq(lexp, run('testd', 2, nil, true))
+    end)
+
+    it('follow=true handles symlink loop', function()
+      local cwd = 'testd/a/b/c'
+      local symlink = cwd .. '/link_loop' ---@type string
+      vim.uv.fs_symlink(vim.uv.fs_realpath(cwd), symlink, { junction = true, dir = true })
+
+      eq(
+        link_limit,
+        exec_lua(function()
+          return #vim.iter(vim.fs.dir(cwd, { depth = math.huge, follow = true })):totable()
+        end)
+      )
     end)
   end)
 
@@ -228,6 +254,53 @@ describe('vim.fs', function()
       eq({ nvim_dir }, vim.fs.find(name, { path = parent, upward = true, type = 'directory' }))
     end)
 
+    it('follows symlinks', function()
+      local build_dir = test_source_path .. '/build' ---@type string
+      local symlink = test_source_path .. '/build_link' ---@type string
+      vim.uv.fs_symlink(build_dir, symlink, { junction = true, dir = true })
+
+      finally(function()
+        vim.uv.fs_unlink(symlink)
+      end)
+
+      eq(
+        { nvim_prog, symlink .. '/bin/' .. nvim_prog_basename },
+        vim.fs.find(nvim_prog_basename, {
+          path = test_source_path,
+          type = 'file',
+          limit = 2,
+          follow = true,
+        })
+      )
+
+      eq(
+        { nvim_prog },
+        vim.fs.find(nvim_prog_basename, {
+          path = test_source_path,
+          type = 'file',
+          limit = 2,
+          follow = false,
+        })
+      )
+    end)
+
+    it('follow=true handles symlink loop', function()
+      local cwd = test_source_path ---@type string
+      local symlink = test_source_path .. '/loop_link' ---@type string
+      vim.uv.fs_symlink(cwd, symlink, { junction = true, dir = true })
+
+      finally(function()
+        vim.uv.fs_unlink(symlink)
+      end)
+
+      eq(link_limit, #vim.fs.find(nvim_prog_basename, {
+        path = test_source_path,
+        type = 'file',
+        limit = math.huge,
+        follow = true,
+      }))
+    end)
+
     it('accepts predicate as names', function()
       local opts = { path = nvim_dir, upward = true, type = 'directory' }
       eq(
@@ -273,14 +346,14 @@ describe('vim.fs', function()
     end)
 
     it('works with a single marker', function()
-      eq(test_source_path, exec_lua([[return vim.fs.root(0, '.git')]]))
+      eq(test_source_path, exec_lua([[return vim.fs.root(0, 'CMakePresets.json')]]))
     end)
 
     it('works with multiple markers', function()
       local bufnr = api.nvim_get_current_buf()
       eq(
         vim.fs.joinpath(test_source_path, 'test/functional/fixtures'),
-        exec_lua([[return vim.fs.root(..., {'CMakeLists.txt', '.git'})]], bufnr)
+        exec_lua([[return vim.fs.root(..., {'CMakeLists.txt', 'CMakePresets.json'})]], bufnr)
       )
     end)
 
@@ -295,26 +368,26 @@ describe('vim.fs', function()
     end)
 
     it('works with a filename argument', function()
-      eq(test_source_path, exec_lua([[return vim.fs.root(..., '.git')]], nvim_prog))
+      eq(test_source_path, exec_lua([[return vim.fs.root(..., 'CMakePresets.json')]], nvim_prog))
     end)
 
     it('works with a relative path', function()
       eq(
         test_source_path,
-        exec_lua([[return vim.fs.root(..., '.git')]], vim.fs.basename(nvim_prog))
+        exec_lua([[return vim.fs.root(..., 'CMakePresets.json')]], vim.fs.basename(nvim_prog))
       )
     end)
 
     it('uses cwd for unnamed buffers', function()
       command('new')
-      eq(test_source_path, exec_lua([[return vim.fs.root(0, '.git')]]))
+      eq(test_source_path, exec_lua([[return vim.fs.root(0, 'CMakePresets.json')]]))
     end)
 
     it("uses cwd for buffers with non-empty 'buftype'", function()
       command('new')
       command('set buftype=nofile')
       command('file lua://')
-      eq(test_source_path, exec_lua([[return vim.fs.root(0, '.git')]]))
+      eq(test_source_path, exec_lua([[return vim.fs.root(0, 'CMakePresets.json')]]))
     end)
   end)
 
@@ -323,6 +396,20 @@ describe('vim.fs', function()
       eq('foo/bar/baz', vim.fs.joinpath('foo', 'bar', 'baz'))
       eq('foo/bar/baz', vim.fs.joinpath('foo', '/bar/', '/baz'))
     end)
+    it('rewrites backslashes on Windows', function()
+      if is_os('win') then
+        eq('foo/bar/baz/zub/', vim.fs.joinpath([[foo]], [[\\bar\\\\baz]], [[zub\]]))
+      else
+        eq([[foo/\\bar\\\\baz/zub\]], vim.fs.joinpath([[foo]], [[\\bar\\\\baz]], [[zub\]]))
+      end
+    end)
+    it('strips redundant slashes', function()
+      if is_os('win') then
+        eq('foo/bar/baz/zub/', vim.fs.joinpath([[foo//]], [[\\bar\\\\baz]], [[zub\]]))
+      else
+        eq('foo/bar/baz/zub/', vim.fs.joinpath([[foo]], [[//bar////baz]], [[zub/]]))
+      end
+    end)
   end)
 
   describe('normalize()', function()
@@ -347,8 +434,8 @@ describe('vim.fs', function()
     end)
 
     -- Opts required for testing posix paths and win paths
-    local posix_opts = is_os('win') and { win = false } or {}
-    local win_opts = is_os('win') and {} or { win = true }
+    local posix_opts = { win = false }
+    local win_opts = { win = true }
 
     it('preserves leading double slashes in POSIX paths', function()
       eq('//foo', vim.fs.normalize('//foo', posix_opts))
@@ -359,6 +446,29 @@ describe('vim.fs', function()
       eq('/foo/bar', vim.fs.normalize('/foo//bar////', posix_opts))
     end)
 
+    it('normalizes drive letter', function()
+      eq('C:/', vim.fs.normalize('C:/', win_opts))
+      eq('C:/', vim.fs.normalize('c:/', win_opts))
+      eq('D:/', vim.fs.normalize('d:/', win_opts))
+      eq('C:', vim.fs.normalize('C:', win_opts))
+      eq('C:', vim.fs.normalize('c:', win_opts))
+      eq('D:', vim.fs.normalize('d:', win_opts))
+      eq('C:/foo/test', vim.fs.normalize('C:/foo/test/', win_opts))
+      eq('C:/foo/test', vim.fs.normalize('c:/foo/test/', win_opts))
+      eq('D:foo/test', vim.fs.normalize('D:foo/test/', win_opts))
+      eq('D:foo/test', vim.fs.normalize('d:foo/test/', win_opts))
+    end)
+
+    it('always treats paths as case-sensitive #31833', function()
+      eq('TEST', vim.fs.normalize('TEST', win_opts))
+      eq('test', vim.fs.normalize('test', win_opts))
+      eq('C:/FOO/test', vim.fs.normalize('C:/FOO/test', win_opts))
+      eq('C:/foo/test', vim.fs.normalize('C:/foo/test', win_opts))
+      eq('//SERVER/SHARE/FOO/BAR', vim.fs.normalize('//SERVER/SHARE/FOO/BAR', win_opts))
+      eq('//server/share/foo/bar', vim.fs.normalize('//server/share/foo/bar', win_opts))
+      eq('C:/FOO/test', vim.fs.normalize('c:/FOO/test', win_opts))
+    end)
+
     it('allows backslashes on unix-based os', function()
       eq('/home/user/hello\\world', vim.fs.normalize('/home/user/hello\\world', posix_opts))
     end)
@@ -454,4 +564,92 @@ describe('vim.fs', function()
       end)
     end)
   end)
+
+  describe('abspath()', function()
+    local cwd = assert(t.fix_slashes(assert(vim.uv.cwd())))
+    local home = t.fix_slashes(assert(vim.uv.os_homedir()))
+
+    it('works', function()
+      eq(cwd .. '/foo', vim.fs.abspath('foo'))
+      eq(cwd .. '/././foo', vim.fs.abspath('././foo'))
+      eq(cwd .. '/.././../foo', vim.fs.abspath('.././../foo'))
+    end)
+
+    it('works with absolute paths', function()
+      if is_os('win') then
+        eq([[C:/foo]], vim.fs.abspath([[C:\foo]]))
+        eq([[C:/foo/../.]], vim.fs.abspath([[C:\foo\..\.]]))
+        eq('//foo/bar', vim.fs.abspath('\\\\foo\\bar'))
+      else
+        eq('/foo/../.', vim.fs.abspath('/foo/../.'))
+        eq('/foo/bar', vim.fs.abspath('/foo/bar'))
+      end
+    end)
+
+    it('expands ~', function()
+      eq(home .. '/foo', vim.fs.abspath('~/foo'))
+      eq(home .. '/./.././foo', vim.fs.abspath('~/./.././foo'))
+    end)
+
+    if is_os('win') then
+      it('works with drive-specific cwd on Windows', function()
+        local cwd_drive = cwd:match('^%w:')
+
+        eq(cwd .. '/foo', vim.fs.abspath(cwd_drive .. 'foo'))
+      end)
+    end
+  end)
+
+  describe('relpath()', function()
+    it('works', function()
+      local cwd = assert(t.fix_slashes(assert(vim.uv.cwd())))
+      local my_dir = vim.fs.joinpath(cwd, 'foo')
+
+      eq(nil, vim.fs.relpath('/var/lib', '/var'))
+      eq(nil, vim.fs.relpath('/var/lib', '/bin'))
+      eq(nil, vim.fs.relpath(my_dir, 'bin'))
+      eq(nil, vim.fs.relpath(my_dir, './bin'))
+      eq(nil, vim.fs.relpath(my_dir, '././'))
+      eq(nil, vim.fs.relpath(my_dir, '../'))
+      eq(nil, vim.fs.relpath('/var/lib', '/'))
+      eq(nil, vim.fs.relpath('/var/lib', '//'))
+      eq(nil, vim.fs.relpath(' ', '/var'))
+      eq(nil, vim.fs.relpath(' ', '/var'))
+      eq('.', vim.fs.relpath('/var/lib', '/var/lib'))
+      eq('lib', vim.fs.relpath('/var/', '/var/lib'))
+      eq('var/lib', vim.fs.relpath('/', '/var/lib'))
+      eq('bar/package.json', vim.fs.relpath('/foo/test', '/foo/test/bar/package.json'))
+      eq('foo/bar', vim.fs.relpath(cwd, 'foo/bar'))
+      eq('foo/bar', vim.fs.relpath('.', vim.fs.joinpath(cwd, 'foo/bar')))
+      eq('bar', vim.fs.relpath('foo', 'foo/bar'))
+      eq(nil, vim.fs.relpath('/var/lib', '/var/library/foo'))
+
+      if is_os('win') then
+        eq(nil, vim.fs.relpath('/', ' '))
+        eq(nil, vim.fs.relpath('/', 'var'))
+      else
+        local cwd_rel_root = cwd:sub(2)
+        eq(cwd_rel_root .. '/ ', vim.fs.relpath('/', ' '))
+        eq(cwd_rel_root .. '/var', vim.fs.relpath('/', 'var'))
+      end
+
+      if is_os('win') then
+        eq(nil, vim.fs.relpath('c:/aaaa/', '/aaaa/cccc'))
+        eq(nil, vim.fs.relpath('c:/aaaa/', './aaaa/cccc'))
+        eq(nil, vim.fs.relpath('c:/aaaa/', 'aaaa/cccc'))
+        eq(nil, vim.fs.relpath('c:/blah\\blah', 'd:/games'))
+        eq(nil, vim.fs.relpath('c:/games', 'd:/games'))
+        eq(nil, vim.fs.relpath('c:/games', 'd:/games/foo'))
+        eq(nil, vim.fs.relpath('c:/aaaa/bbbb', 'c:/aaaa'))
+        eq('cccc', vim.fs.relpath('c:/aaaa/', 'c:/aaaa/cccc'))
+        eq('aaaa/bbbb', vim.fs.relpath('C:/', 'c:\\aaaa\\bbbb'))
+        eq('bar/package.json', vim.fs.relpath('C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json'))
+        eq('baz', vim.fs.relpath('\\\\foo\\bar', '\\\\foo\\bar\\baz'))
+        eq(nil, vim.fs.relpath('a/b/c', 'a\\b'))
+        eq('d', vim.fs.relpath('a/b/c', 'a\\b\\c\\d'))
+        eq('.', vim.fs.relpath('\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'))
+        eq(nil, vim.fs.relpath('C:\\foo\\test', 'C:\\foo\\Test\\bar\\package.json'))
+      end
+    end)
+  end)
 end)
diff --git a/test/functional/lua/func_memoize_spec.lua b/test/functional/lua/func_memoize_spec.lua
new file mode 100644
index 0000000000..ca518ab88d
--- /dev/null
+++ b/test/functional/lua/func_memoize_spec.lua
@@ -0,0 +1,142 @@
+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('vim.func._memoize', function()
+  before_each(clear)
+
+  it('caches function results based on their parameters', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize('concat', function(arg1, arg2)
+        _G.count = _G.count + 1
+        return arg1 + arg2
+      end)
+
+      collectgarbage('stop')
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      collectgarbage('restart')
+    ]])
+
+    eq(1, exec_lua([[return _G.count]]))
+  end)
+
+  it('caches function results using a weak table by default', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize('concat-2', function(arg1, arg2)
+        _G.count = _G.count + 1
+        return arg1 + arg2
+      end)
+
+      adder(3, -4)
+      collectgarbage()
+      adder(3, -4)
+      collectgarbage()
+      adder(3, -4)
+    ]])
+
+    eq(3, exec_lua([[return _G.count]]))
+  end)
+
+  it('can cache using a strong table', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize('concat-2', function(arg1, arg2)
+        _G.count = _G.count + 1
+        return arg1 + arg2
+      end, false)
+
+      adder(3, -4)
+      collectgarbage()
+      adder(3, -4)
+      collectgarbage()
+      adder(3, -4)
+    ]])
+
+    eq(1, exec_lua([[return _G.count]]))
+  end)
+
+  it('can clear a single cache entry', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize(function(arg1, arg2)
+        return tostring(arg1) .. '%%' .. tostring(arg2)
+      end, function(arg1, arg2)
+        _G.count = _G.count + 1
+        return arg1 + arg2
+      end)
+
+      collectgarbage('stop')
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      adder(3, -4)
+      adder:clear(3, -4)
+      adder(3, -4)
+      collectgarbage('restart')
+    ]])
+
+    eq(2, exec_lua([[return _G.count]]))
+  end)
+
+  it('can clear the entire cache', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize(function(arg1, arg2)
+        return tostring(arg1) .. '%%' .. tostring(arg2)
+      end, function(arg1, arg2)
+        _G.count = _G.count + 1
+        return arg1 + arg2
+      end)
+
+      collectgarbage('stop')
+      adder(1, 2)
+      adder(3, -4)
+      adder(1, 2)
+      adder(3, -4)
+      adder(1, 2)
+      adder(3, -4)
+      adder:clear()
+      adder(1, 2)
+      adder(3, -4)
+      collectgarbage('restart')
+    ]])
+
+    eq(4, exec_lua([[return _G.count]]))
+  end)
+
+  it('can cache functions that return nil', function()
+    exec_lua([[
+      _G.count = 0
+
+      local adder = vim.func._memoize('concat', function(arg1, arg2)
+        _G.count = _G.count + 1
+        return nil
+      end)
+
+      collectgarbage('stop')
+      adder(1, 2)
+      adder(1, 2)
+      adder(1, 2)
+      adder(1, 2)
+      adder:clear()
+      adder(1, 2)
+      collectgarbage('restart')
+    ]])
+
+    eq(2, exec_lua([[return _G.count]]))
+  end)
+end)
diff --git a/test/functional/lua/hl_spec.lua b/test/functional/lua/hl_spec.lua
index 89881973bf..512f6be48f 100644
--- a/test/functional/lua/hl_spec.lua
+++ b/test/functional/lua/hl_spec.lua
@@ -104,6 +104,33 @@ describe('vim.hl.range', function()
                                                                   |
     ]])
   end)
+
+  it('removes highlight after given `timeout`', function()
+    local timeout = 100
+    exec_lua(function()
+      local ns = vim.api.nvim_create_namespace('')
+      vim.hl.range(0, ns, 'Search', { 0, 0 }, { 4, 0 }, { timeout = timeout })
+    end)
+    screen:expect({
+      grid = [[
+      {10:^asdfghjkl}{100:$}                                                  |
+      {10:«口=口»}{100:$}                                                    |
+      {10:qwertyuiop}{100:$}                                                 |
+      {10:口口=口口}{1:$}                                                  |
+      zxcvbnm{1:$}                                                    |
+                                                                  |
+    ]],
+      timeout = timeout,
+    })
+    screen:expect([[
+      ^asdfghjkl{1:$}                                                  |
+      «口=口»{1:$}                                                    |
+      qwertyuiop{1:$}                                                 |
+      口口=口口{1:$}                                                  |
+      zxcvbnm{1:$}                                                    |
+                                                                  |
+    ]])
+  end)
 end)
 
 describe('vim.hl.on_yank', function()
@@ -144,7 +171,7 @@ describe('vim.hl.on_yank', function()
       vim.api.nvim_buf_set_mark(0, ']', 1, 1, {})
       vim.hl.on_yank({ timeout = math.huge, on_macro = true, event = { operator = 'y' } })
     end)
-    local ns = api.nvim_create_namespace('hlyank')
+    local ns = api.nvim_create_namespace('nvim.hlyank')
     local win = api.nvim_get_current_win()
     eq({ win }, api.nvim__ns_get(ns).wins)
     command('wincmd w')
@@ -158,7 +185,7 @@ describe('vim.hl.on_yank', function()
       vim.api.nvim_buf_set_mark(0, ']', 1, 1, {})
       vim.hl.on_yank({ timeout = math.huge, on_macro = true, event = { operator = 'y' } })
     end)
-    local ns = api.nvim_create_namespace('hlyank')
+    local ns = api.nvim_create_namespace('nvim.hlyank')
     eq(api.nvim_get_current_win(), api.nvim__ns_get(ns).wins[1])
     command('wincmd w')
     exec_lua(function()
diff --git a/test/functional/lua/json_spec.lua b/test/functional/lua/json_spec.lua
index a6e814d739..e4a1df1d4c 100644
--- a/test/functional/lua/json_spec.lua
+++ b/test/functional/lua/json_spec.lua
@@ -152,6 +152,45 @@ describe('vim.json.encode()', function()
     clear()
   end)
 
+  it('escape_slash', function()
+    -- With slash
+    eq('"Test\\/"', exec_lua([[return vim.json.encode('Test/', { escape_slash = true })]]))
+    eq(
+      'Test/',
+      exec_lua([[return vim.json.decode(vim.json.encode('Test/', { escape_slash = true }))]])
+    )
+
+    -- Without slash