test: support upvalues in exec_lua

1 files changed, 281 insertions, 238 deletions

diff --git a/test/functional/plugin/lsp/diagnostic_spec.lua b/test/functional/plugin/lsp/diagnostic_spec.lua
index 76b1808883..78c684083b 100644
--- a/test/functional/plugin/lsp/diagnostic_spec.lua
+++ b/test/functional/plugin/lsp/diagnostic_spec.lua
@@ -11,7 +11,9 @@ local neq = t.neq
 local create_server_definition = t_lsp.create_server_definition
 
 describe('vim.lsp.diagnostic', function()
-  local fake_uri
+  local fake_uri --- @type string
+  local client_id --- @type integer
+  local diagnostic_bufnr --- @type integer
 
   before_each(function()
     clear { env = {
@@ -19,79 +21,98 @@ describe('vim.lsp.diagnostic', function()
       VIMRUNTIME = os.getenv 'VIMRUNTIME',
     } }
 
-    exec_lua [[
+    exec_lua(function()
       require('vim.lsp')
 
-      make_range = function(x1, y1, x2, y2)
+      _G.make_range = function(x1, y1, x2, y2)
         return { start = { line = x1, character = y1 }, ['end'] = { line = x2, character = y2 } }
       end
 
-      make_error = function(msg, x1, y1, x2, y2)
+      _G.make_error = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 1,
         }
       end
 
-      make_warning = function(msg, x1, y1, x2, y2)
+      _G.make_warning = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 2,
         }
       end
 
-      make_information = function(msg, x1, y1, x2, y2)
+      _G.make_information = function(msg, x1, y1, x2, y2)
         return {
-          range = make_range(x1, y1, x2, y2),
+          range = _G.make_range(x1, y1, x2, y2),
           message = msg,
           severity = 3,
         }
       end
 
-      function get_extmarks(bufnr, client_id)
-        local namespace = vim.lsp.diagnostic.get_namespace(client_id)
+      function _G.get_extmarks(bufnr, client_id0)
+        local namespace = vim.lsp.diagnostic.get_namespace(client_id0)
         local ns = vim.diagnostic.get_namespace(namespace)
         local extmarks = {}
         if ns.user_data.virt_text_ns then
-          for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {details=true})) do
+          for _, e in
+            pairs(
+              vim.api.nvim_buf_get_extmarks(
+                bufnr,
+                ns.user_data.virt_text_ns,
+                0,
+                -1,
+                { details = true }
+              )
+            )
+          do
             table.insert(extmarks, e)
           end
         end
         if ns.user_data.underline_ns then
-          for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {details=true})) do
+          for _, e in
+            pairs(
+              vim.api.nvim_buf_get_extmarks(
+                bufnr,
+                ns.user_data.underline_ns,
+                0,
+                -1,
+                { details = true }
+              )
+            )
+          do
             table.insert(extmarks, e)
           end
         end
         return extmarks
       end
 
-      client_id = vim.lsp.start_client {
+      client_id = assert(vim.lsp.start_client {
         cmd_env = {
-          NVIM_LUA_NOTRACK = "1";
-        };
+          NVIM_LUA_NOTRACK = '1',
+        },
         cmd = {
-          vim.v.progpath, '-es', '-u', 'NONE', '--headless'
-        };
-        offset_encoding = "utf-16";
-      }
-    ]]
+          vim.v.progpath,
+          '-es',
+          '-u',
+          'NONE',
+          '--headless',
+        },
+        offset_encoding = 'utf-16',
+      })
+    end)
 
     fake_uri = 'file:///fake/uri'
 
-    exec_lua(
-      [[
-      fake_uri = ...
+    exec_lua(function()
       diagnostic_bufnr = vim.uri_to_bufnr(fake_uri)
-      local lines = {"1st line of text", "2nd line of text", "wow", "cool", "more", "lines"}
+      local lines = { '1st line of text', '2nd line of text', 'wow', 'cool', 'more', 'lines' }
       vim.fn.bufload(diagnostic_bufnr)
       vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, 1, false, lines)
       vim.api.nvim_win_set_buf(0, diagnostic_bufnr)
-      return diagnostic_bufnr
-    ]],
-      fake_uri
-    )
+    end)
   end)
 
   after_each(function()
@@ -101,89 +122,73 @@ describe('vim.lsp.diagnostic', function()
   describe('vim.lsp.diagnostic.on_publish_diagnostics', function()
     it('allows configuring the virtual text via vim.lsp.with', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+      local extmarks = exec_lua(function()
+        _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
           virtual_text = {
-            spacing = ...,
+            spacing = expected_spacing,
           },
         })
 
-        PublishDiagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('Delayed Diagnostic', 4, 4, 4, 4),
-            }
-          }, {client_id=client_id}
-        )
+        _G.PublishDiagnostics(nil, {
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
+          },
+        }, { client_id = client_id })
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
 
-      local virt_text = extmarks[1][4].virt_text
-      local spacing = virt_text[1][1]
+      local spacing = extmarks[1][4].virt_text[1][1]
 
       eq(expected_spacing, #spacing)
     end)
 
     it('allows configuring the virtual text via vim.lsp.with using a function', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        spacing = ...
-
-        PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+      local extmarks = exec_lua(function()
+        _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
           virtual_text = function()
             return {
-              spacing = spacing,
+              spacing = expected_spacing,
             }
           end,
         })
 
-        PublishDiagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('Delayed Diagnostic', 4, 4, 4, 4),
-            }
-          }, {client_id=client_id}
-        )
+        _G.PublishDiagnostics(nil, {
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('Delayed Diagnostic', 4, 4, 4, 4),
+          },
+        }, { client_id = client_id })
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
 
-      local virt_text = extmarks[1][4].virt_text
-      local spacing = virt_text[1][1]
+      local spacing = extmarks[1][4].virt_text[1][1]
 
       eq(expected_spacing, #spacing)
     end)
 
     it('allows filtering via severity limit', function()
       local get_extmark_count_with_severity = function(severity_limit)
-        return exec_lua(
-          [[
-          PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+        return exec_lua(function()
+          _G.PublishDiagnostics = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
             underline = false,
             virtual_text = {
-              severity = { min = ... }
+              severity = { min = severity_limit },
             },
           })
 
-          PublishDiagnostics(nil, {
-              uri = fake_uri,
-              diagnostics = {
-                make_warning('Delayed Diagnostic', 4, 4, 4, 4),
-              }
-            }, {client_id=client_id}
-          )
-
-          return #get_extmarks(diagnostic_bufnr, client_id)
-        ]],
-          severity_limit
-        )
+          _G.PublishDiagnostics(nil, {
+            uri = fake_uri,
+            diagnostics = {
+              _G.make_warning('Delayed Diagnostic', 4, 4, 4, 4),
+            },
+          }, { client_id = client_id })
+
+          return #_G.get_extmarks(diagnostic_bufnr, client_id)
+        end, client_id, fake_uri, severity_limit)
       end
 
       -- No messages with Error or higher
@@ -196,246 +201,284 @@ describe('vim.lsp.diagnostic', function()
 
     it('correctly handles UTF-16 offsets', function()
       local line = 'All 💼 and no 🎉 makes Jack a dull 👦'
-      local result = exec_lua(
-        [[
-        local line = ...
-        vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, -1, false, {line})
+      local result = exec_lua(function()
+        vim.api.nvim_buf_set_lines(diagnostic_bufnr, 0, -1, false, { line })
 
         vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-            uri = fake_uri,
-            diagnostics = {
-              make_error('UTF-16 Diagnostic', 0, 7, 0, 8),
-            }
-          }, {client_id=client_id}
-        )
+          uri = fake_uri,
+          diagnostics = {
+            _G.make_error('UTF-16 Diagnostic', 0, 7, 0, 8),
+          },
+        }, { client_id = client_id })
 
         local diags = vim.diagnostic.get(diagnostic_bufnr)
         vim.lsp.stop_client(client_id)
         vim.api.nvim_exec_autocmds('VimLeavePre', { modeline = false })
         return diags
-      ]],
-        line
-      )
+      end)
       eq(1, #result)
-      eq(exec_lua([[return vim.str_byteindex(..., 7, true)]], line), result[1].col)
-      eq(exec_lua([[return vim.str_byteindex(..., 8, true)]], line), result[1].end_col)
+      eq(
+        exec_lua(function()
+          return vim.str_byteindex(line, 7, true)
+        end),
+        result[1].col
+      )
+      eq(
+        exec_lua(function()
+          return vim.str_byteindex(line, 8, true)
+        end),
+        result[1].end_col
+      )
     end)
 
     it('does not create buffer on empty diagnostics', function()
-      local bufnr
-
       -- No buffer is created without diagnostics
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {},
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      eq(-1, bufnr)
+      eq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {},
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
 
       -- Create buffer on diagnostics
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {
-            make_error('Diagnostic', 0, 0, 0, 0),
-          },
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      neq(-1, bufnr)
-      eq(1, exec_lua([[return #vim.diagnostic.get(...)]], bufnr))
+      neq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {
+              _G.make_error('Diagnostic', 0, 0, 0, 0),
+            },
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(_G.bufnr)
+        end)
+      )
 
       -- Clear diagnostics after buffer was created
-      bufnr = exec_lua [[
-        vim.lsp.diagnostic.on_publish_diagnostics(nil, {
-          uri = "file:///fake/uri2",
-          diagnostics = {},
-        }, {client_id=client_id})
-        return vim.fn.bufnr(vim.uri_to_fname("file:///fake/uri2"))
-      ]]
-      neq(-1, bufnr)
-      eq(0, exec_lua([[return #vim.diagnostic.get(...)]], bufnr))
+      neq(
+        -1,
+        exec_lua(function()
+          vim.lsp.diagnostic.on_publish_diagnostics(nil, {
+            uri = 'file:///fake/uri2',
+            diagnostics = {},
+          }, { client_id = client_id })
+          return vim.fn.bufnr(vim.uri_to_fname('file:///fake/uri2'))
+        end)
+      )
+      eq(
+        0,
+        exec_lua(function()
+          return #vim.diagnostic.get(_G.bufnr)
+        end)
+      )
     end)
   end)
 
   describe('vim.lsp.diagnostic.on_diagnostic', function()
     before_each(function()
       exec_lua(create_server_definition)
-      exec_lua([[
-        server = _create_server({
+      exec_lua(function()
+        _G.server = _G._create_server({
           capabilities = {
-            diagnosticProvider = {
-            }
-          }
+            diagnosticProvider = {},
+          },
         })
 
-        function get_extmarks(bufnr, client_id)
-          local namespace = vim.lsp.diagnostic.get_namespace(client_id, true)
+        function _G.get_extmarks(bufnr, client_id0)
+          local namespace = vim.lsp.diagnostic.get_namespace(client_id0, true)
           local ns = vim.diagnostic.get_namespace(namespace)
           local extmarks = {}
           if ns.user_data.virt_text_ns then
-            for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.virt_text_ns, 0, -1, {details=true})) do
+            for _, e in
+              pairs(
+                vim.api.nvim_buf_get_extmarks(
+                  bufnr,
+                  ns.user_data.virt_text_ns,
+                  0,
+                  -1,
+                  { details = true }
+                )
+              )
+            do
               table.insert(extmarks, e)
             end
           end
           if ns.user_data.underline_ns then
-            for _, e in pairs(vim.api.nvim_buf_get_extmarks(bufnr, ns.user_data.underline_ns, 0, -1, {details=true})) do
+            for _, e in
+              pairs(
+                vim.api.nvim_buf_get_extmarks(
+                  bufnr,
+                  ns.user_data.underline_ns,
+                  0,
+                  -1,
+                  { details = true }
+                )
+              )
+            do
               table.insert(extmarks, e)
             end
           end
           return extmarks
         end
 
-        client_id = vim.lsp.start({ name = 'dummy', cmd = server.cmd })
-      ]])
+        client_id = vim.lsp.start({ name = 'dummy', cmd = _G.server.cmd })
+      end)
     end)
 
     it('adds diagnostics to vim.diagnostics', function()
-      local diags = exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      local diags = exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
 
         return vim.diagnostic.get(diagnostic_bufnr)
-      ]])
+      end)
       eq(1, #diags)
       eq('Pull Diagnostic', diags[1].message)
     end)
 
     it('severity defaults to error if missing', function()
       ---@type vim.Diagnostic[]
-      local diagnostics = exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              {
-                range = make_range(4, 4, 4, 4),
-                message = "bad!",
-              }
-            }
-          },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
+      local diagnostics = exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            {
+              range = _G.make_range(4, 4, 4, 4),
+              message = 'bad!',
             },
-            uri = fake_uri,
-            client_id = client_id,
           },
-          {}
-        )
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
+          },
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
         return vim.diagnostic.get(diagnostic_bufnr)
-      ]])
+      end)
       eq(1, #diagnostics)
       eq(1, diagnostics[1].severity)
     end)
 
     it('allows configuring the virtual text via vim.lsp.with', function()
       local expected_spacing = 10
-      local extmarks = exec_lua(
-        [[
-        Diagnostic = vim.lsp.with(vim.lsp.diagnostic.on_diagnostic, {
+      local extmarks = exec_lua(function()
+        _G.Diagnostic = vim.lsp.with(vim.lsp.diagnostic.on_diagnostic, {
           virtual_text = {
-            spacing = ...,
+            spacing = expected_spacing,
           },
         })
 
-        Diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+        _G.Diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
 
-        return get_extmarks(diagnostic_bufnr, client_id)
-      ]],
-        expected_spacing
-      )
+        return _G.get_extmarks(diagnostic_bufnr, client_id)
+      end)
       eq(2, #extmarks)
       eq(expected_spacing, #extmarks[1][4].virt_text[1][1])
     end)
 
     it('clears diagnostics when client detaches', function()
-      exec_lua([[
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      exec_lua(function()
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
-      ]])
-      local diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
+      end)
+
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
 
-      exec_lua([[ vim.lsp.stop_client(client_id) ]])
+      exec_lua(function()
+        vim.lsp.stop_client(client_id)
+      end)
 
-      diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(0, #diags)
+      eq(
+        0,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
     end)
 
     it('keeps diagnostics when one client detaches and others still are attached', function()
-      exec_lua([[
-        client_id2 = vim.lsp.start({ name = 'dummy2', cmd = server.cmd })
-
-        vim.lsp.diagnostic.on_diagnostic(nil,
-          {
-            kind = 'full',
-            items = {
-              make_error('Pull Diagnostic', 4, 4, 4, 4),
-            }
+      local client_id2
+      exec_lua(function()
+        client_id2 = vim.lsp.start({ name = 'dummy2', cmd = _G.server.cmd })
+
+        vim.lsp.diagnostic.on_diagnostic(nil, {
+          kind = 'full',
+          items = {
+            _G.make_error('Pull Diagnostic', 4, 4, 4, 4),
           },
-          {
-            params = {
-              textDocument = { uri = fake_uri },
-            },
-            uri = fake_uri,
-            client_id = client_id,
+        }, {
+          params = {
+            textDocument = { uri = fake_uri },
           },
-          {}
-        )
-      ]])
-      local diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+          uri = fake_uri,
+          client_id = client_id,
+        }, {})
+      end)
+
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
 
-      exec_lua([[ vim.lsp.stop_client(client_id2) ]])
+      exec_lua(function()
+        vim.lsp.stop_client(client_id2)
+      end)
 
-      diags = exec_lua([[return vim.diagnostic.get(diagnostic_bufnr)]])
-      eq(1, #diags)
+      eq(
+        1,
+        exec_lua(function()
+          return #vim.diagnostic.get(diagnostic_bufnr)
+        end)
+      )
     end)
   end)
 end)