Patch 8.2.5029
Problem:    "textlock" is always zero.
Solution:   Remove "textlock" and rename "textwinlock" to "textlock".
            (closes #10489)
Files:      runtime/doc/insert.txt, runtime/doc/tags, src/beval.c,
            src/change.c, src/edit.c, src/errors.h, src/eval.c, src/ex_cmds.c,
            src/ex_getln.c, src/proto/ex_getln.pro, src/globals.h,
            src/indent.c, src/insexpand.c, src/map.c, src/register.c,
            src/undo.c, src/window.c, src/testdir/test_edit.vim,
            src/testdir/test_ins_complete.vim, src/testdir/test_popup.vim,
            src/testdir/test_quickfix.vim


*** ../vim-8.2.5028/runtime/doc/insert.txt      2022-05-22 14:48:26.331247290 
+0100
--- runtime/doc/insert.txt      2022-05-27 17:18:23.106509646 +0100
***************
*** 671,677 ****
  ends CTRL-X mode (any key that is not a valid CTRL-X mode command) is mapped.
  Also, when doing completion with 'complete' mappings apply as usual.
  
!                                                       *E578* *E565*
  Note: While completion is active Insert mode can't be used recursively and
  buffer text cannot be changed.  Mappings that somehow invoke ":normal i.."
  will generate an E565 error.
--- 671,677 ----
  ends CTRL-X mode (any key that is not a valid CTRL-X mode command) is mapped.
  Also, when doing completion with 'complete' mappings apply as usual.
  
!                                                               *E565*
  Note: While completion is active Insert mode can't be used recursively and
  buffer text cannot be changed.  Mappings that somehow invoke ":normal i.."
  will generate an E565 error.
*** ../vim-8.2.5028/runtime/doc/tags    2022-05-22 14:48:26.367247284 +0100
--- runtime/doc/tags    2022-05-27 17:18:23.106509646 +0100
***************
*** 4749,4755 ****
  E575  starting.txt    /*E575*
  E576  starting.txt    /*E576*
  E577  starting.txt    /*E577*
- E578  insert.txt      /*E578*
  E579  eval.txt        /*E579*
  E580  eval.txt        /*E580*
  E581  eval.txt        /*E581*
--- 4749,4754 ----
*** ../vim-8.2.5028/src/beval.c 2022-01-22 15:09:32.493898829 +0000
--- src/beval.c 2022-05-27 17:18:23.106509646 +0100
***************
*** 284,290 ****
            curbuf = save_curbuf;
            if (use_sandbox)
                ++sandbox;
!           ++textwinlock;
  
            if (bexpr == p_bexpr)
            {
--- 284,290 ----
            curbuf = save_curbuf;
            if (use_sandbox)
                ++sandbox;
!           ++textlock;
  
            if (bexpr == p_bexpr)
            {
***************
*** 311,317 ****
  
            if (use_sandbox)
                --sandbox;
!           --textwinlock;
            current_sctx = save_sctx;
  
            set_vim_var_string(VV_BEVAL_TEXT, NULL, -1);
--- 311,317 ----
  
            if (use_sandbox)
                --sandbox;
!           --textlock;
            current_sctx = save_sctx;
  
            set_vim_var_string(VV_BEVAL_TEXT, NULL, -1);
*** ../vim-8.2.5028/src/change.c        2022-05-23 13:10:39.726713326 +0100
--- src/change.c        2022-05-27 17:18:23.106509646 +0100
***************
*** 324,330 ****
            next = lnr->lr_next;
            if (lnr->lr_id == id)
            {
!               if (textwinlock > 0)
                {
                    // in invoke_listeners(), clear ID and delete later
                    lnr->lr_id = 0;
--- 324,330 ----
            next = lnr->lr_next;
            if (lnr->lr_id == id)
            {
!               if (textlock > 0)
                {
                    // in invoke_listeners(), clear ID and delete later
                    lnr->lr_id = 0;
***************
*** 401,407 ****
  
      argv[4].v_type = VAR_LIST;
      argv[4].vval.v_list = buf->b_recorded_changes;
!     ++textwinlock;
  
      for (lnr = buf->b_listener; lnr != NULL; lnr = lnr->lr_next)
      {
--- 401,407 ----
  
      argv[4].v_type = VAR_LIST;
      argv[4].vval.v_list = buf->b_recorded_changes;
!     ++textlock;
  
      for (lnr = buf->b_listener; lnr != NULL; lnr = lnr->lr_next)
      {
***************
*** 421,427 ****
            prev = lnr;
      }
  
!     --textwinlock;
      list_unref(buf->b_recorded_changes);
      buf->b_recorded_changes = NULL;
  
--- 421,427 ----
            prev = lnr;
      }
  
!     --textlock;
      list_unref(buf->b_recorded_changes);
      buf->b_recorded_changes = NULL;
  
*** ../vim-8.2.5028/src/edit.c  2022-05-21 20:16:51.003567195 +0100
--- src/edit.c  2022-05-27 17:18:23.106509646 +0100
***************
*** 168,175 ****
      // Don't allow changes in the buffer while editing the cmdline.  The
      // caller of getcmdline() may get confused.
      // Don't allow recursive insert mode when busy with completion.
!     if (textwinlock != 0 || textlock != 0
!                         || ins_compl_active() || compl_busy || pum_visible())
      {
        emsg(_(e_not_allowed_to_change_text_or_change_window));
        return FALSE;
--- 168,174 ----
      // Don't allow changes in the buffer while editing the cmdline.  The
      // caller of getcmdline() may get confused.
      // Don't allow recursive insert mode when busy with completion.
!     if (textlock != 0 || ins_compl_active() || compl_busy || pum_visible())
      {
        emsg(_(e_not_allowed_to_change_text_or_change_window));
        return FALSE;
***************
*** 5342,5348 ****
      }
  
      // Lock the text to avoid weird things from happening.
!     ++textwinlock;
      set_vim_var_string(VV_CHAR, buf, -1);  // set v:char
  
      res = NULL;
--- 5341,5347 ----
      }
  
      // Lock the text to avoid weird things from happening.
!     ++textlock;
      set_vim_var_string(VV_CHAR, buf, -1);  // set v:char
  
      res = NULL;
***************
*** 5356,5362 ****
      }
  
      set_vim_var_string(VV_CHAR, NULL, -1);  // clear v:char
!     --textwinlock;
  
      // Restore the State, it may have been changed.
      State = save_State;
--- 5355,5361 ----
      }
  
      set_vim_var_string(VV_CHAR, NULL, -1);  // clear v:char
!     --textlock;
  
      // Restore the State, it may have been changed.
      State = save_State;
*** ../vim-8.2.5028/src/errors.h        2022-05-22 19:13:45.496327034 +0100
--- src/errors.h        2022-05-27 17:18:23.106509646 +0100
***************
*** 1458,1465 ****
  EXTERN char e_illegal_register_name[]
        INIT(= N_("Illegal register name"));
  #endif
! EXTERN char e_not_allowed_to_change_text_here[]
!       INIT(= N_("E578: Not allowed to change text here"));
  #ifdef FEAT_EVAL
  EXTERN char e_if_nesting_too_deep[]
        INIT(= N_("E579: :if nesting too deep"));
--- 1458,1464 ----
  EXTERN char e_illegal_register_name[]
        INIT(= N_("Illegal register name"));
  #endif
! // E578 unused
  #ifdef FEAT_EVAL
  EXTERN char e_if_nesting_too_deep[]
        INIT(= N_("E579: :if nesting too deep"));
*** ../vim-8.2.5028/src/eval.c  2022-05-22 22:07:48.059725754 +0100
--- src/eval.c  2022-05-27 17:18:23.110509642 +0100
***************
*** 543,549 ****
  
  /*
   * Call eval_to_string() without using current local variables and using
!  * textwinlock.  When "use_sandbox" is TRUE use the sandbox.
   * Use legacy Vim script syntax.
   */
      char_u *
--- 543,549 ----
  
  /*
   * Call eval_to_string() without using current local variables and using
!  * textlock.  When "use_sandbox" is TRUE use the sandbox.
   * Use legacy Vim script syntax.
   */
      char_u *
***************
*** 562,573 ****
      save_funccal(&funccal_entry);
      if (use_sandbox)
        ++sandbox;
!     ++textwinlock;
      may_garbage_collect = FALSE;
      retval = eval_to_string(arg, FALSE);
      if (use_sandbox)
        --sandbox;
!     --textwinlock;
      may_garbage_collect = save_garbage;
      restore_funccal();
      current_sctx.sc_version = save_sc_version;
--- 562,573 ----
      save_funccal(&funccal_entry);
      if (use_sandbox)
        ++sandbox;
!     ++textlock;
      may_garbage_collect = FALSE;
      retval = eval_to_string(arg, FALSE);
      if (use_sandbox)
        --sandbox;
!     --textlock;
      may_garbage_collect = save_garbage;
      restore_funccal();
      current_sctx.sc_version = save_sc_version;
***************
*** 807,813 ****
      ++emsg_off;
      if (use_sandbox)
        ++sandbox;
!     ++textwinlock;
      *cp = NUL;
      if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL)
        retval = 0;
--- 807,813 ----
      ++emsg_off;
      if (use_sandbox)
        ++sandbox;
!     ++textlock;
      *cp = NUL;
      if (eval0(arg, &tv, NULL, &EVALARG_EVALUATE) == FAIL)
        retval = 0;
***************
*** 832,838 ****
      --emsg_off;
      if (use_sandbox)
        --sandbox;
!     --textwinlock;
      clear_evalarg(&EVALARG_EVALUATE, NULL);
      current_sctx = saved_sctx;
  
--- 832,838 ----
      --emsg_off;
      if (use_sandbox)
        --sandbox;
!     --textlock;
      clear_evalarg(&EVALARG_EVALUATE, NULL);
      current_sctx = saved_sctx;
  
*** ../vim-8.2.5028/src/ex_cmds.c       2022-05-18 13:11:53.159464114 +0100
--- src/ex_cmds.c       2022-05-27 17:18:23.110509642 +0100
***************
*** 4414,4427 ****
                subflags_save = subflags;
  
                // Disallow changing text or switching window in an expression.
!               ++textwinlock;
  #endif
                // get length of substitution part
                sublen = vim_regsub_multi(&regmatch,
                                    sub_firstlnum - regmatch.startpos[0].lnum,
                               sub, sub_firstline, FALSE, magic_isset(), TRUE);
  #ifdef FEAT_EVAL
!               --textwinlock;
  
                // If getting the substitute string caused an error, don't do
                // the replacement.
--- 4414,4427 ----
                subflags_save = subflags;
  
                // Disallow changing text or switching window in an expression.
!               ++textlock;
  #endif
                // get length of substitution part
                sublen = vim_regsub_multi(&regmatch,
                                    sub_firstlnum - regmatch.startpos[0].lnum,
                               sub, sub_firstline, FALSE, magic_isset(), TRUE);
  #ifdef FEAT_EVAL
!               --textlock;
  
                // If getting the substitute string caused an error, don't do
                // the replacement.
***************
*** 4524,4536 ****
                new_end += copy_len;
  
  #ifdef FEAT_EVAL
!               ++textwinlock;
  #endif
                (void)vim_regsub_multi(&regmatch,
                                    sub_firstlnum - regmatch.startpos[0].lnum,
                                      sub, new_end, TRUE, magic_isset(), TRUE);
  #ifdef FEAT_EVAL
!               --textwinlock;
  #endif
                sub_nsubs++;
                did_sub = TRUE;
--- 4524,4536 ----
                new_end += copy_len;
  
  #ifdef FEAT_EVAL
!               ++textlock;
  #endif
                (void)vim_regsub_multi(&regmatch,
                                    sub_firstlnum - regmatch.startpos[0].lnum,
                                      sub, new_end, TRUE, magic_isset(), TRUE);
  #ifdef FEAT_EVAL
!               --textlock;
  #endif
                sub_nsubs++;
                did_sub = TRUE;
*** ../vim-8.2.5028/src/ex_getln.c      2022-05-17 20:10:58.744361606 +0100
--- src/ex_getln.c      2022-05-27 17:18:23.110509642 +0100
***************
*** 850,861 ****
        c = get_expr_register();
        if (c == '=')
        {
!           // Need to save and restore ccline.  And set "textwinlock"
            // to avoid nasty things like going to another buffer when
            // evaluating an expression.
!           ++textwinlock;
            p = get_expr_line();
!           --textwinlock;
  
            if (p != NULL)
            {
--- 850,861 ----
        c = get_expr_register();
        if (c == '=')
        {
!           // Need to save and restore ccline.  And set "textlock"
            // to avoid nasty things like going to another buffer when
            // evaluating an expression.
!           ++textlock;
            p = get_expr_line();
!           --textlock;
  
            if (p != NULL)
            {
***************
*** 2710,2722 ****
   * 'balloonexpr', etc.
   */
      int
! text_and_win_locked(void)
  {
  #ifdef FEAT_CMDWIN
      if (cmdwin_type != 0)
        return TRUE;
  #endif
!     return textwinlock != 0;
  }
  
  /*
--- 2710,2722 ----
   * 'balloonexpr', etc.
   */
      int
! text_locked(void)
  {
  #ifdef FEAT_CMDWIN
      if (cmdwin_type != 0)
        return TRUE;
  #endif
!     return textlock != 0;
  }
  
  /*
***************
*** 2736,2754 ****
      if (cmdwin_type != 0)
        return e_invalid_in_cmdline_window;
  #endif
!     if (textwinlock != 0)
!       return e_not_allowed_to_change_text_or_change_window;
!     return e_not_allowed_to_change_text_here;
! }
! 
! /*
!  * Return TRUE when the text must not be changed and/or we cannot switch to
!  * another window.  TRUE while evaluating 'completefunc'.
!  */
!     int
! text_locked(void)
! {
!     return text_and_win_locked() || textlock != 0;
  }
  
  /*
--- 2736,2742 ----
      if (cmdwin_type != 0)
        return e_invalid_in_cmdline_window;
  #endif
!     return e_not_allowed_to_change_text_or_change_window;
  }
  
  /*
***************
*** 3730,3740 ****
      regname = may_get_selection(regname);
  #endif
  
!     // Need to  set "textwinlock" to avoid nasty things like going to another
      // buffer when evaluating an expression.
!     ++textwinlock;
      i = get_spec_reg(regname, &arg, &allocated, TRUE);
!     --textwinlock;
  
      if (i)
      {
--- 3718,3728 ----
      regname = may_get_selection(regname);
  #endif
  
!     // Need to set "textlock" to avoid nasty things like going to another
      // buffer when evaluating an expression.
!     ++textlock;
      i = get_spec_reg(regname, &arg, &allocated, TRUE);
!     --textlock;
  
      if (i)
      {
*** ../vim-8.2.5028/src/proto/ex_getln.pro      2022-05-07 12:48:24.074194794 
+0100
--- src/proto/ex_getln.pro      2022-05-27 17:18:23.114509641 +0100
***************
*** 3,9 ****
  char_u *getcmdline(int firstc, long count, int indent, getline_opt_T 
do_concat);
  char_u *getcmdline_prompt(int firstc, char_u *prompt, int attr, int 
xp_context, char_u *xp_arg);
  int check_opt_wim(void);
- int text_and_win_locked(void);
  void text_locked_msg(void);
  char *get_text_locked_msg(void);
  int text_locked(void);
--- 3,8 ----
*** ../vim-8.2.5028/src/globals.h       2022-05-21 20:16:51.011567174 +0100
--- src/globals.h       2022-05-27 17:18:23.110509642 +0100
***************
*** 846,861 ****
                                // allowed, e.g. when sourcing .exrc or .vimrc
                                // in current directory
  
! EXTERN int    textwinlock INIT(= 0);
                                // non-zero when changing text and jumping to
                                // another window or editing another buffer is
                                // not allowed
  
- EXTERN int    textlock INIT(= 0);
-                               // non-zero when changing text is not allowed,
-                               // jumping to another window is allowed,
-                               // editing another buffer is not allowed.
- 
  EXTERN int    curbuf_lock INIT(= 0);
                                // non-zero when the current buffer can't be
                                // changed.  Used for FileChangedRO.
--- 846,856 ----
                                // allowed, e.g. when sourcing .exrc or .vimrc
                                // in current directory
  
! EXTERN int    textlock INIT(= 0);
                                // non-zero when changing text and jumping to
                                // another window or editing another buffer is
                                // not allowed
  
  EXTERN int    curbuf_lock INIT(= 0);
                                // non-zero when the current buffer can't be
                                // changed.  Used for FileChangedRO.
*** ../vim-8.2.5028/src/indent.c        2022-05-21 20:16:51.003567195 +0100
--- src/indent.c        2022-05-27 17:18:23.110509642 +0100
***************
*** 1872,1878 ****
      set_vim_var_nr(VV_LNUM, curwin->w_cursor.lnum);
      if (use_sandbox)
        ++sandbox;
!     ++textwinlock;
      current_sctx = curbuf->b_p_script_ctx[BV_INDE];
  
      // Need to make a copy, the 'indentexpr' option could be changed while
--- 1872,1878 ----
      set_vim_var_nr(VV_LNUM, curwin->w_cursor.lnum);
      if (use_sandbox)
        ++sandbox;
!     ++textlock;
      current_sctx = curbuf->b_p_script_ctx[BV_INDE];
  
      // Need to make a copy, the 'indentexpr' option could be changed while
***************
*** 1886,1892 ****
  
      if (use_sandbox)
        --sandbox;
!     --textwinlock;
      current_sctx = save_sctx;
  
      // Restore the cursor position so that 'indentexpr' doesn't need to.
--- 1886,1892 ----
  
      if (use_sandbox)
        --sandbox;
!     --textlock;
      current_sctx = save_sctx;
  
      // Restore the cursor position so that 'indentexpr' doesn't need to.
*** ../vim-8.2.5028/src/insexpand.c     2022-05-26 15:23:22.913780366 +0100
--- src/insexpand.c     2022-05-27 17:18:23.110509642 +0100
***************
*** 1144,1152 ****
      dict_set_items_ro(v_event);
  
      recursive = TRUE;
!     textwinlock++;
      apply_autocmds(EVENT_COMPLETECHANGED, NULL, NULL, FALSE, curbuf);
!     textwinlock--;
      recursive = FALSE;
  
      restore_v_event(v_event, &save_v_event);
--- 1144,1152 ----
      dict_set_items_ro(v_event);
  
      recursive = TRUE;
!     textlock++;
      apply_autocmds(EVENT_COMPLETECHANGED, NULL, NULL, FALSE, curbuf);
!     textlock--;
      recursive = FALSE;
  
      restore_v_event(v_event, &save_v_event);
***************
*** 2643,2649 ****
      // Lock the text to avoid weird things from happening.  Also disallow
      // switching to another window, it should not be needed and may end up in
      // Insert mode in another buffer.
!     ++textwinlock;
  
      cb = get_insert_callback(type);
      retval = call_callback(cb, 0, &rettv, 2, args);
--- 2643,2649 ----
      // Lock the text to avoid weird things from happening.  Also disallow
      // switching to another window, it should not be needed and may end up in
      // Insert mode in another buffer.
!     ++textlock;
  
      cb = get_insert_callback(type);
      retval = call_callback(cb, 0, &rettv, 2, args);
***************
*** 2669,2675 ****
                break;
        }
      }
!     --textwinlock;
  
      curwin->w_cursor = pos;   // restore the cursor position
      validate_cursor();
--- 2669,2675 ----
                break;
        }
      }
!     --textlock;
  
      curwin->w_cursor = pos;   // restore the cursor position
      validate_cursor();
***************
*** 2867,2873 ****
  f_complete(typval_T *argvars, typval_T *rettv UNUSED)
  {
      int           startcol;
-     int           save_textlock = textlock;
  
      if (in_vim9script()
            && (check_for_number_arg(argvars, 0) == FAIL
--- 2867,2872 ----
***************
*** 2880,2889 ****
        return;
      }
  
-     // "textlock" is set when evaluating 'completefunc' but we can change
-     // text here.
-     textlock = 0;
- 
      // Check for undo allowed here, because if something was already inserted
      // the line was already saved for undo and this check isn't done.
      if (!undo_allowed())
--- 2879,2884 ----
***************
*** 2897,2903 ****
        if (startcol > 0)
            set_completion(startcol - 1, argvars[1].vval.v_list);
      }
-     textlock = save_textlock;
  }
  
  /*
--- 2892,2897 ----
***************
*** 4508,4517 ****
      args[1].vval.v_string = (char_u *)"";
      args[2].v_type = VAR_UNKNOWN;
      pos = curwin->w_cursor;
!     ++textwinlock;
      cb = get_insert_callback(ctrl_x_mode);
      col = call_callback_retnr(cb, 2, args);
!     --textwinlock;
  
      State = save_State;
      curwin->w_cursor = pos;   // restore the cursor position
--- 4502,4511 ----
      args[1].vval.v_string = (char_u *)"";
      args[2].v_type = VAR_UNKNOWN;
      pos = curwin->w_cursor;
!     ++textlock;
      cb = get_insert_callback(ctrl_x_mode);
      col = call_callback_retnr(cb, 2, args);
!     --textlock;
  
      State = save_State;
      curwin->w_cursor = pos;   // restore the cursor position
*** ../vim-8.2.5028/src/map.c   2022-05-10 17:49:33.259775085 +0100
--- src/map.c   2022-05-27 17:18:23.114509641 +0100
***************
*** 1695,1701 ****
  
      // Forbid changing text or using ":normal" to avoid most of the bad side
      // effects.  Also restore the cursor position.
!     ++textwinlock;
      ++ex_normal_lock;
      set_vim_var_char(c);  // set v:char to the typed character
      save_cursor = curwin->w_cursor;
--- 1695,1701 ----
  
      // Forbid changing text or using ":normal" to avoid most of the bad side
      // effects.  Also restore the cursor position.
!     ++textlock;
      ++ex_normal_lock;
      set_vim_var_char(c);  // set v:char to the typed character
      save_cursor = curwin->w_cursor;
***************
*** 1710,1716 ****
      // Note: the evaluation may make "mp" invalid.
      p = eval_to_string(expr, FALSE);
  
!     --textwinlock;
      --ex_normal_lock;
      curwin->w_cursor = save_cursor;
      msg_col = save_msg_col;
--- 1710,1716 ----
      // Note: the evaluation may make "mp" invalid.
      p = eval_to_string(expr, FALSE);
  
!     --textlock;
      --ex_normal_lock;
      curwin->w_cursor = save_cursor;
      msg_col = save_msg_col;
*** ../vim-8.2.5028/src/register.c      2022-05-25 15:15:34.739409287 +0100
--- src/register.c      2022-05-27 17:18:23.114509641 +0100
***************
*** 1055,1063 ****
      dict_set_items_ro(v_event);
  
      recursive = TRUE;
!     textwinlock++;
      apply_autocmds(EVENT_TEXTYANKPOST, NULL, NULL, FALSE, curbuf);
!     textwinlock--;
      recursive = FALSE;
  
      // Empty the dictionary, v:event is still valid
--- 1055,1063 ----
      dict_set_items_ro(v_event);
  
      recursive = TRUE;
!     textlock++;
      apply_autocmds(EVENT_TEXTYANKPOST, NULL, NULL, FALSE, curbuf);
!     textlock--;
      recursive = FALSE;
  
      // Empty the dictionary, v:event is still valid
*** ../vim-8.2.5028/src/undo.c  2022-05-26 15:56:18.073351934 +0100
--- src/undo.c  2022-05-27 17:18:23.114509641 +0100
***************
*** 331,339 ****
  
      // Don't allow changes in the buffer while editing the cmdline.  The
      // caller of getcmdline() may get confused.
!     if (textwinlock != 0 || textlock != 0)
      {
!       emsg(_(e_not_allowed_to_change_text_here));
        return FALSE;
      }
  
--- 331,339 ----
  
      // Don't allow changes in the buffer while editing the cmdline.  The
      // caller of getcmdline() may get confused.
!     if (textlock != 0)
      {
!       emsg(_(e_not_allowed_to_change_text_or_change_window));
        return FALSE;
      }
  
*** ../vim-8.2.5028/src/window.c        2022-05-18 16:29:04.345637132 +0100
--- src/window.c        2022-05-27 17:18:23.114509641 +0100
***************
*** 4584,4590 ****
        return;
      }
  #endif
!     if (text_and_win_locked())
      {
        beep_flush();
        text_locked_msg();
--- 4584,4590 ----
        return;
      }
  #endif
!     if (text_locked())
      {
        beep_flush();
        text_locked_msg();
*** ../vim-8.2.5028/src/testdir/test_edit.vim   2022-05-21 20:16:51.011567174 
+0100
--- src/testdir/test_edit.vim   2022-05-27 17:18:23.114509641 +0100
***************
*** 1041,1047 ****
    set completefunc=CompleteFunc
    call setline(1, ['', 'abcd', ''])
    2d
!   call assert_fails("normal 2G$a\<C-X>\<C-U>", 'E578:')
    bwipe!
  endfunc
  
--- 1041,1047 ----
    set completefunc=CompleteFunc
    call setline(1, ['', 'abcd', ''])
    2d
!   call assert_fails("normal 2G$a\<C-X>\<C-U>", 'E565:')
    bwipe!
  endfunc
  
*** ../vim-8.2.5028/src/testdir/test_ins_complete.vim   2022-05-26 
15:23:22.917780369 +0100
--- src/testdir/test_ins_complete.vim   2022-05-27 17:18:23.114509641 +0100
***************
*** 698,704 ****
    endfunc
    set completefunc=CompleteFunc
    call setline(1, ['', 'abcd', ''])
!   call assert_fails('exe "normal 2G$a\<C-X>\<C-U>"', 'E578:')
  
    " delete text when called for the second time
    func CompleteFunc2(findstart, base)
--- 698,704 ----
    endfunc
    set completefunc=CompleteFunc
    call setline(1, ['', 'abcd', ''])
!   call assert_fails('exe "normal 2G$a\<C-X>\<C-U>"', 'E565:')
  
    " delete text when called for the second time
    func CompleteFunc2(findstart, base)
***************
*** 710,716 ****
    endfunc
    set completefunc=CompleteFunc2
    call setline(1, ['', 'abcd', ''])
!   call assert_fails('exe "normal 2G$a\<C-X>\<C-U>"', 'E578:')
  
    " Jump to a different window from the complete function
    func CompleteFunc3(findstart, base)
--- 710,716 ----
    endfunc
    set completefunc=CompleteFunc2
    call setline(1, ['', 'abcd', ''])
!   call assert_fails('exe "normal 2G$a\<C-X>\<C-U>"', 'E565:')
  
    " Jump to a different window from the complete function
    func CompleteFunc3(findstart, base)
*** ../vim-8.2.5028/src/testdir/test_popup.vim  2022-04-30 15:02:17.900266675 
+0100
--- src/testdir/test_popup.vim  2022-05-27 17:18:23.114509641 +0100
***************
*** 655,661 ****
    set completefunc=MessComplete
    new
    call setline(1, 'Ju')
!   call assert_fails('call feedkeys("A\<c-x>\<c-u>/\<esc>", "tx")', 'E578:')
    call assert_equal('Jan/', getline(1))
    bwipe!
    set completefunc=
--- 655,661 ----
    set completefunc=MessComplete
    new
    call setline(1, 'Ju')
!   call assert_fails('call feedkeys("A\<c-x>\<c-u>/\<esc>", "tx")', 'E565:')
    call assert_equal('Jan/', getline(1))
    bwipe!
    set completefunc=
*** ../vim-8.2.5028/src/testdir/test_quickfix.vim       2022-04-11 
15:11:34.637531944 +0100
--- src/testdir/test_quickfix.vim       2022-05-27 17:18:23.114509641 +0100
***************
*** 3474,3480 ****
  func Test_vimgrep_with_textlock()
    new
  
!   " Simple way to execute something with "textwinlock" set.
    " Check that vimgrep without jumping can be executed.
    au InsertCharPre * vimgrep /RunTheTest/j runtest.vim
    normal ax
--- 3474,3480 ----
  func Test_vimgrep_with_textlock()
    new
  
!   " Simple way to execute something with "textlock" set.
    " Check that vimgrep without jumping can be executed.
    au InsertCharPre * vimgrep /RunTheTest/j runtest.vim
    normal ax
*** ../vim-8.2.5028/src/version.c       2022-05-27 15:35:23.850892910 +0100
--- src/version.c       2022-05-27 17:20:09.302429656 +0100
***************
*** 736,737 ****
--- 736,739 ----
  {   /* Add new patch number below this line */
+ /**/
+     5029,
  /**/

-- 
Not too long ago, compress was something you did to garbage...

 /// Bram Moolenaar -- [email protected] -- http://www.Moolenaar.net   \\\
///                                                                      \\\
\\\        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ ///
 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///

-- 
-- 
You received this message from the "vim_dev" maillist.
Do not top-post! Type your reply below the text you are replying to.
For more information, visit http://www.vim.org/maillist.php

--- 
You received this message because you are subscribed to the Google Groups 
"vim_dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/vim_dev/20220527162835.545F71C1929%40moolenaar.net.

Raspunde prin e-mail lui