vim-patch:9.1.0047: issues with temp curwin/buf while cmdwin is open

Problem:  Things that temporarily change/restore curwin/buf (e.g:
          win_execute, some autocmds) may break assumptions that
          curwin/buf is the cmdwin when "cmdwin_type != 0", causing
          issues.

Solution: Expose the cmdwin's real win/buf and check that instead. Also
          try to ensure these variables are NULL if "cmdwin_type == 0",
          allowing them to be used directly in most cases without
          checking cmdwin_type. (Sean Dewar)

Reset and save `cmdwin_old_curwin` in a similar fashion.
Apply suitable changes for API functions and add Lua tests.

988f74311c

src/nvim/api/vim.c

@@ -1022,7 +1022,7 @@ Integer nvim_open_term(Buffer buffer, Dict(open_term) *opts, Error *err)
     return 0;
   }
 
-  if (cmdwin_type != 0 && buf == curbuf) {
+  if (buf == cmdwin_buf) {
     api_set_error(err, kErrorTypeException, "%s", e_cmdwin);
     return 0;
   }

src/nvim/api/win_config.c

@@ -181,7 +181,7 @@ Window nvim_open_win(Buffer buffer, Boolean enter, Dict(float_config) *config, E
   if (!buf) {
     return 0;
   }
-  if (cmdwin_type != 0 && (enter || buf == curbuf)) {
+  if ((cmdwin_type != 0 && enter) || buf == cmdwin_buf) {
     api_set_error(err, kErrorTypeException, "%s", e_cmdwin);
     return 0;
   }

src/nvim/api/window.c

@@ -61,7 +61,7 @@ void nvim_win_set_buf(Window window, Buffer buffer, Error *err)
   if (!win || !buf) {
     return;
   }
-  if (cmdwin_type != 0 && (win == curwin || win == cmdwin_old_curwin || buf == curbuf)) {
+  if (win == cmdwin_win || win == cmdwin_old_curwin || buf == cmdwin_buf) {
     api_set_error(err, kErrorTypeException, "%s", e_cmdwin);
     return;
   }

src/nvim/drawline.c

@@ -1219,7 +1219,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
     statuscol.draw = true;
     statuscol.sattrs = wlv.sattrs;
     statuscol.foldinfo = foldinfo;
-    statuscol.width = win_col_off(wp) - (cmdwin_type != 0 && wp == curwin);
+    statuscol.width = win_col_off(wp) - (wp == cmdwin_win);
     statuscol.use_cul = use_cursor_line_highlight(wp, lnum);
     statuscol.sign_cul_id = statuscol.use_cul ? sign_cul_attr : 0;
     statuscol.num_attr = sign_num_attr > 0 ? syn_id2attr(sign_num_attr) : 0;
@@ -1511,7 +1511,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
 
       assert(wlv.off == 0);
 
-      if (cmdwin_type != 0 && wp == curwin) {
+      if (wp == cmdwin_win) {
         // Draw the cmdline character.
         draw_col_fill(&wlv, schar_from_ascii(cmdwin_type), 1, win_hl_attr(wp, HLF_AT));
       }

src/nvim/eval/window.c

@@ -755,7 +755,7 @@ void f_win_gettype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     rettv->vval.v_string = xstrdup("preview");
   } else if (wp->w_floating) {
     rettv->vval.v_string = xstrdup("popup");
-  } else if (wp == curwin && cmdwin_type != 0) {
+  } else if (wp == cmdwin_win) {
     rettv->vval.v_string = xstrdup("command");
   } else if (bt_quickfix(wp->w_buffer)) {
     rettv->vval.v_string = xstrdup((wp->w_llist_ref != NULL ? "loclist" : "quickfix"));

src/nvim/ex_cmds.c

@@ -2305,10 +2305,19 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     // If the current buffer was empty and has no file name, curbuf
     // is returned by buflist_new(), nothing to do here.
     if (buf != curbuf) {
+      // Should only be possible to get here if the cmdwin is closed, or
+      // if it's opening and its buffer hasn't been set yet (the new
+      // buffer is for it).
+      assert(cmdwin_buf == NULL);
+
       const int save_cmdwin_type = cmdwin_type;
+      win_T *const save_cmdwin_win = cmdwin_win;
+      win_T *const save_cmdwin_old_curwin = cmdwin_old_curwin;
 
       // BufLeave applies to the old buffer.
       cmdwin_type = 0;
+      cmdwin_win = NULL;
+      cmdwin_old_curwin = NULL;
 
       // Be careful: The autocommands may delete any buffer and change
       // the current buffer.
@@ -2324,7 +2333,11 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
       const bufref_T save_au_new_curbuf = au_new_curbuf;
       set_bufref(&au_new_curbuf, buf);
       apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, false, curbuf);
+
       cmdwin_type = save_cmdwin_type;
+      cmdwin_win = save_cmdwin_win;
+      cmdwin_old_curwin = save_cmdwin_old_curwin;
+
       if (!bufref_valid(&au_new_curbuf)) {
         // New buffer has been deleted.
         delbuf_msg(new_name);  // Frees new_name.

src/nvim/ex_getln.c

@@ -4326,9 +4326,10 @@ static int open_cmdwin(void)
   // Don't let quitting the More prompt make this fail.
   got_int = false;
 
-  // Set "cmdwin_type" before any autocommands may mess things up.
+  // Set "cmdwin_..." variables before any autocommands may mess things up.
   cmdwin_type = get_cmdline_type();
   cmdwin_level = ccline.level;
+  cmdwin_win = curwin;
   cmdwin_old_curwin = old_curwin;
 
   // Create empty command-line buffer.
@@ -4337,9 +4338,12 @@ static int open_cmdwin(void)
     win_close(curwin, true, false);
     ga_clear(&winsizes);
     cmdwin_type = 0;
+    cmdwin_win = NULL;
     cmdwin_old_curwin = NULL;
     return Ctrl_C;
   }
+  cmdwin_buf = curbuf;
+
   // Command-line buffer has bufhidden=wipe, unlike a true "scratch" buffer.
   set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
   curbuf->b_p_ma = true;
@@ -4434,6 +4438,8 @@ static int open_cmdwin(void)
 
   cmdwin_type = 0;
   cmdwin_level = 0;
+  cmdwin_buf = NULL;
+  cmdwin_win = NULL;
   cmdwin_old_curwin = NULL;
 
   exmode_active = save_exmode;

src/nvim/globals.h

@@ -752,6 +752,8 @@ EXTERN bool km_startsel INIT( = false);
 EXTERN int cmdwin_type INIT( = 0);    ///< type of cmdline window or 0
 EXTERN int cmdwin_result INIT( = 0);  ///< result of cmdline window or 0
 EXTERN int cmdwin_level INIT( = 0);   ///< cmdline recursion level
+EXTERN buf_T *cmdwin_buf INIT( = NULL);  ///< buffer of cmdline window or NULL
+EXTERN win_T *cmdwin_win INIT( = NULL);  ///< window of cmdline window or NULL
 EXTERN win_T *cmdwin_old_curwin INIT( = NULL);  ///< curwin before opening cmdline window or NULL
 
 EXTERN char no_lines_msg[] INIT( = N_("--No lines in buffer--"));

src/nvim/mouse.c

@@ -1326,18 +1326,18 @@ retnomove:
                 && !sep_line_offset
                 && (wp->w_p_rl
                     ? col < wp->w_width_inner - fdc
-                    : col >= fdc + (cmdwin_type == 0 && wp == curwin ? 0 : 1))
+                    : col >= fdc + (wp != cmdwin_win ? 0 : 1))
                 && (flags & MOUSE_MAY_STOP_VIS)))) {
       end_visual_mode();
       redraw_curbuf_later(UPD_INVERTED);  // delete the inversion
     }
-    if (cmdwin_type != 0 && wp != curwin) {
+    if (cmdwin_type != 0 && wp != cmdwin_win) {
       // A click outside the command-line window: Use modeless
       // selection if possible.  Allow dragging the status lines.
       sep_line_offset = 0;
       row = 0;
       col += wp->w_wincol;
-      wp = curwin;
+      wp = cmdwin_win;
     }
     // Only change window focus when not clicking on or dragging the
     // status line.  Do change focus when releasing the mouse button

src/nvim/move.c

@@ -760,7 +760,7 @@ int win_col_off(win_T *wp)
 {
   return ((wp->w_p_nu || wp->w_p_rnu || *wp->w_p_stc != NUL)
           ? (number_width(wp) + (*wp->w_p_stc == NUL)) : 0)
-         + ((cmdwin_type == 0 || wp != curwin) ? 0 : 1)
+         + ((wp != cmdwin_win) ? 0 : 1)
          + win_fdccol_count(wp) + (wp->w_scwidth * SIGN_WIDTH);
 }
 

src/nvim/textformat.c

@@ -763,7 +763,7 @@ int comp_textwidth(bool ff)
     // The width is the window width minus 'wrapmargin' minus all the
     // things that add to the margin.
     textwidth = curwin->w_width_inner - (int)curbuf->b_p_wm;
-    if (cmdwin_type != 0) {
+    if (curbuf == cmdwin_buf) {
       textwidth -= 1;
     }
     textwidth -= win_fdccol_count(curwin);

src/nvim/window.c

@@ -2485,7 +2485,7 @@ bool can_close_in_cmdwin(win_T *win, Error *err)
   FUNC_ATTR_NONNULL_ALL
 {
   if (cmdwin_type != 0) {
-    if (win == curwin) {
+    if (win == cmdwin_win) {
       cmdwin_result = Ctrl_C;
       return false;
     } else if (win == cmdwin_old_curwin) {
@@ -3030,6 +3030,9 @@ void win_free_all(void)
 {
   // avoid an error for switching tabpage with the cmdline window open
   cmdwin_type = 0;
+  cmdwin_buf = NULL;
+  cmdwin_win = NULL;
+  cmdwin_old_curwin = NULL;
 
   while (first_tabpage->tp_next != NULL) {
     tabpage_close(true);

test/functional/api/window_spec.lua

@@ -1,18 +1,20 @@
 local helpers = require('test.functional.helpers')(after_each)
 local Screen = require('test.functional.ui.screen')
-local clear, curbuf, curbuf_contents, curwin, eq, neq, ok, feed, insert, eval =
+local clear, curbuf, curbuf_contents, curwin, eq, neq, matches, ok, feed, insert, eval =
   helpers.clear,
   helpers.api.nvim_get_current_buf,
   helpers.curbuf_contents,
   helpers.api.nvim_get_current_win,
   helpers.eq,
   helpers.neq,
+  helpers.matches,
   helpers.ok,
   helpers.feed,
   helpers.insert,
   helpers.eval
 local poke_eventloop = helpers.poke_eventloop
 local exec = helpers.exec
+local exec_lua = helpers.exec_lua
 local fn = helpers.fn
 local request = helpers.request
 local NIL = vim.NIL
@@ -51,7 +53,7 @@ describe('API/win', function()
       eq('Invalid window id: 23', pcall_err(api.nvim_win_set_buf, 23, api.nvim_get_current_buf()))
     end)
 
-    it('disallowed in cmdwin if win={old_}curwin or buf=curbuf', function()
+    it('disallowed in cmdwin if win=cmdwin_{old_cur}win or buf=cmdwin_buf', function()
       local new_buf = api.nvim_create_buf(true, true)
       local old_win = api.nvim_get_current_win()
       local new_win = api.nvim_open_win(new_buf, false, {
@@ -74,6 +76,36 @@ describe('API/win', function()
         'E11: Invalid in command-line window; <CR> executes, CTRL-C quits',
         pcall_err(api.nvim_win_set_buf, new_win, 0)
       )
+      matches(
+        'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
+        pcall_err(
+          exec_lua,
+          [[
+           local cmdwin_buf = vim.api.nvim_get_current_buf()
+           local new_win, new_buf = ...
+           vim.api.nvim_buf_call(new_buf, function()
+             vim.api.nvim_win_set_buf(new_win, cmdwin_buf)
+           end)
+         ]],
+          new_win,
+          new_buf
+        )
+      )
+      matches(
+        'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
+        pcall_err(
+          exec_lua,
+          [[
+           local cmdwin_win = vim.api.nvim_get_current_win()
+           local new_win, new_buf = ...
+           vim.api.nvim_win_call(new_win, function()
+             vim.api.nvim_win_set_buf(cmdwin_win, new_buf)
+           end)
+         ]],
+          new_win,
+          new_buf
+        )
+      )
 
       local next_buf = api.nvim_create_buf(true, true)
       api.nvim_win_set_buf(new_win, next_buf)
@@ -546,6 +578,7 @@ describe('API/win', function()
     it('in cmdline-window #9767', function()
       command('split')
       eq(2, #api.nvim_list_wins())
+      local oldbuf = api.nvim_get_current_buf()
       local oldwin = api.nvim_get_current_win()
       local otherwin = api.nvim_open_win(0, false, {
         relative = 'editor',
@@ -570,6 +603,46 @@ describe('API/win', function()
       api.nvim_win_close(0, true)
       eq(2, #api.nvim_list_wins())
       eq('', fn.getcmdwintype())
+
+      -- Closing curwin in context of a different window shouldn't close cmdwin.
+      otherwin = api.nvim_open_win(0, false, {
+        relative = 'editor',
+        row = 10,
+        col = 10,
+        width = 10,
+        height = 10,
+      })
+      feed('q:')
+      exec_lua(
+        [[
+        vim.api.nvim_win_call(..., function()
+          vim.api.nvim_win_close(0, true)
+        end)
+      ]],
+        otherwin
+      )
+      eq(false, api.nvim_win_is_valid(otherwin))
+      eq(':', fn.getcmdwintype())
+      -- Closing cmdwin in context of a non-previous window is still OK.
+      otherwin = api.nvim_open_win(oldbuf, false, {
+        relative = 'editor',
+        row = 10,
+        col = 10,
+        width = 10,
+        height = 10,
+      })
+      exec_lua(
+        [[
+        local otherwin, cmdwin = ...
+        vim.api.nvim_win_call(otherwin, function()
+          vim.api.nvim_win_close(cmdwin, true)
+        end)
+      ]],
+        otherwin,
+        api.nvim_get_current_win()
+      )
+      eq('', fn.getcmdwintype())
+      eq(true, api.nvim_win_is_valid(otherwin))
     end)
 
     it('closing current (float) window of another tabpage #15313', function()
@@ -646,6 +719,7 @@ describe('API/win', function()
       api.nvim_win_hide(0)
       eq('', fn.getcmdwintype())
 
+      local old_buf = api.nvim_get_current_buf()
       local old_win = api.nvim_get_current_win()
       local other_win = api.nvim_open_win(0, false, {
         relative = 'win',
@@ -663,6 +737,45 @@ describe('API/win', function()
       -- Can close other windows.
       api.nvim_win_hide(other_win)
       eq(false, api.nvim_win_is_valid(other_win))
+
+      -- Closing curwin in context of a different window shouldn't close cmdwin.
+      other_win = api.nvim_open_win(old_buf, false, {
+        relative = 'editor',
+        row = 10,
+        col = 10,
+        width = 10,
+        height = 10,
+      })
+      exec_lua(
+        [[
+        vim.api.nvim_win_call(..., function()
+          vim.api.nvim_win_hide(0)
+        end)
+      ]],
+        other_win
+      )
+      eq(false, api.nvim_win_is_valid(other_win))
+      eq(':', fn.getcmdwintype())
+      -- Closing cmdwin in context of a non-previous window is still OK.
+      other_win = api.nvim_open_win(old_buf, false, {
+        relative = 'editor',
+        row = 10,
+        col = 10,
+        width = 10,
+        height = 10,
+      })
+      exec_lua(
+        [[
+        local otherwin, cmdwin = ...
+        vim.api.nvim_win_call(otherwin, function()
+          vim.api.nvim_win_hide(cmdwin)
+        end)
+      ]],
+        other_win,
+        api.nvim_get_current_win()
+      )
+      eq('', fn.getcmdwintype())
+      eq(true, api.nvim_win_is_valid(other_win))
     end)
   end)
 
@@ -1055,7 +1168,7 @@ describe('API/win', function()
       eq(1, fn.exists('g:fired'))
     end)
 
-    it('disallowed in cmdwin if enter=true or buf=curbuf', function()
+    it('disallowed in cmdwin if enter=true or buf=cmdwin_buf', function()
       local new_buf = api.nvim_create_buf(true, true)
       feed('q:')
       eq(
@@ -1078,6 +1191,20 @@ describe('API/win', function()
           height = 5,
         })
       )
+      matches(
+        'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
+        pcall_err(
+          exec_lua,
+          [[
+           local cmdwin_buf = vim.api.nvim_get_current_buf()
+           vim.api.nvim_buf_call(vim.api.nvim_create_buf(false, true), function()
+             vim.api.nvim_open_win(cmdwin_buf, false, {
+               relative='editor', row=5, col=5, width=5, height=5,
+             })
+           end)
+         ]]
+        )
+      )
 
       eq(
         new_buf,

test/functional/vimscript/api_functions_spec.lua

@@ -3,6 +3,7 @@ local Screen = require('test.functional.ui.screen')
 local neq, eq, command = helpers.neq, helpers.eq, helpers.command
 local clear = helpers.clear
 local exc_exec, expect, eval = helpers.exc_exec, helpers.expect, helpers.eval
+local exec_lua = helpers.exec_lua
 local insert, pcall_err = helpers.insert, helpers.pcall_err
 local matches = helpers.matches
 local api = helpers.api
@@ -106,6 +107,19 @@ describe('eval-API', function()
       pcall_err(api.nvim_open_term, 0, {})
     )
 
+    matches(
+      'E11: Invalid in command%-line window; <CR> executes, CTRL%-C quits$',
+      pcall_err(
+        exec_lua,
+        [[
+         local cmdwin_buf = vim.api.nvim_get_current_buf()
+         vim.api.nvim_buf_call(vim.api.nvim_create_buf(false, true), function()
+           vim.api.nvim_open_term(cmdwin_buf, {})
+         end)
+       ]]
+      )
+    )
+
     -- But turning a different buffer into a terminal from the cmdwin is OK.
     local term_buf = api.nvim_create_buf(false, true)
     api.nvim_open_term(term_buf, {})

test/old/testdir/test_cmdwin.vim

@@ -93,4 +93,37 @@ func Test_cmdwin_restore_heights()
   set cmdheight& showtabline& laststatus&
 endfunc
 
+func Test_cmdwin_temp_curwin()
+  func CheckWraps(expect_wrap)
+    setlocal textwidth=0 wrapmargin=1
+
+    call deletebufline('', 1, '$')
+    let as = repeat('a', winwidth(0) - 2 - &wrapmargin)
+    call setline(1, as .. ' b')
+    normal! gww
+
+    setlocal textwidth& wrapmargin&
+    call assert_equal(a:expect_wrap ? [as, 'b'] : [as .. ' b'], getline(1, '$'))
+  endfunc
+
+  func CheckCmdWin()
+    call assert_equal('command', win_gettype())
+    " textoff and &wrapmargin formatting considers the cmdwin_type char.
+    call assert_equal(1, getwininfo(win_getid())[0].textoff)
+    call CheckWraps(1)
+  endfunc
+
+  func CheckOtherWin()
+    call assert_equal('', win_gettype())
+    call assert_equal(0, getwininfo(win_getid())[0].textoff)
+    call CheckWraps(0)
+  endfunc
+
+  call feedkeys("q::call CheckCmdWin()\<CR>:call win_execute(win_getid(winnr('#')), 'call CheckOtherWin()')\<CR>:q<CR>", 'ntx')
+
+  delfunc CheckWraps
+  delfunc CheckCmdWin
+  delfunc CheckOtherWin
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab