vim-patch:8.2.1698: cannot lock a variable in legacy Vim script like in Vim9 (#21883)

Problem:    Cannot lock a variable in legacy Vim script like in Vim9.
Solution:   Make ":lockvar 0" work.

https://github.com/vim/vim/commit/a187c43cfe8863d48b2159d695fedcb71f8525c1

Co-authored-by: Bram Moolenaar <Bram@vim.org>

10 files changed, 115 insertions, 301 deletions

diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 0ac8152144..58759a6053 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -2681,6 +2681,8 @@ text...
 
 			[depth] is relevant when locking a |List| or
 			|Dictionary|.  It specifies how deep the locking goes:
+				0	Lock the variable {name} but not its
+					value.
 				1	Lock the |List| or |Dictionary| itself,
 					cannot add or remove items, but can
 					still change their values.
@@ -2694,7 +2696,14 @@ text...
 					|Dictionary|, one level deeper.
 			The default [depth] is 2, thus when {name} is a |List|
 			or |Dictionary| the values cannot be changed.
-								*E743*
+
+			Example with [depth] 0: >
+				let mylist = [1, 2, 3]
+				lockvar 0 mylist
+				let mylist[0] = 77   	" OK
+				call add(mylist, 4]  	" OK
+				let mylist = [7, 8, 9]  " Error!
+<								*E743*
 			For unlimited depth use [!] and omit [depth].
 			However, there is a maximum depth of 100 to catch
 			loops.
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index f58fb3f371..4c880aaf92 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -1485,9 +1485,9 @@ char *get_lval(char *const name, typval_T *const rettv, lval_T *const lp, const
         tv_clear(&var1);
         break;
         // existing variable, need to check if it can be changed
-      } else if (!(flags & GLV_READ_ONLY) && var_check_ro(lp->ll_di->di_flags,
-                                                          (const char *)name,
-                                                          (size_t)(p - name))) {
+      } else if (!(flags & GLV_READ_ONLY)
+                 && (var_check_ro(lp->ll_di->di_flags, name, (size_t)(p - name))
+                     || var_check_lock(lp->ll_di->di_flags, name, (size_t)(p - name)))) {
         tv_clear(&var1);
         return NULL;
       }
@@ -1618,7 +1618,7 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
         semsg(_(e_letwrong), op);
         return;
       }
-      if (var_check_lock(lp->ll_blob->bv_lock, lp->ll_name, TV_CSTRING)) {
+      if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, TV_CSTRING)) {
         return;
       }
 
@@ -1681,10 +1681,10 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
       set_var_const(lp->ll_name, lp->ll_name_len, rettv, copy, is_const);
     }
     *endp = (char)cc;
-  } else if (var_check_lock(lp->ll_newkey == NULL
-                            ? lp->ll_tv->v_lock
-                            : lp->ll_tv->vval.v_dict->dv_lock,
-                            lp->ll_name, TV_CSTRING)) {
+  } else if (value_check_lock(lp->ll_newkey == NULL
+                              ? lp->ll_tv->v_lock
+                              : lp->ll_tv->vval.v_dict->dv_lock,
+                              lp->ll_name, TV_CSTRING)) {
     // Skip
   } else if (lp->ll_range) {
     listitem_T *ll_li = lp->ll_li;
@@ -1698,8 +1698,8 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
     // Check whether any of the list items is locked
     for (ri = tv_list_first(rettv->vval.v_list);
          ri != NULL && ll_li != NULL;) {
-      if (var_check_lock(TV_LIST_ITEM_TV(ll_li)->v_lock, lp->ll_name,
-                         TV_CSTRING)) {
+      if (value_check_lock(TV_LIST_ITEM_TV(ll_li)->v_lock, lp->ll_name,
+                           TV_CSTRING)) {
         return;
       }
       ri = TV_LIST_ITEM_NEXT(rettv->vval.v_list, ri);
@@ -4795,12 +4795,12 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
   } else if (argvars[0].v_type == VAR_LIST) {
     if ((l = argvars[0].vval.v_list) == NULL
         || (!map
-            && var_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE))) {
+            && value_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE))) {
       return;
     }
   } else if (argvars[0].v_type == VAR_DICT) {
     if ((d = argvars[0].vval.v_dict) == NULL
-        || (!map && var_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
+        || (!map && value_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
       return;
     }
   } else {
@@ -4839,7 +4839,7 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
 
           dictitem_T *di = TV_DICT_HI2DI(hi);
           if (map
-              && (var_check_lock(di->di_tv.v_lock, arg_errmsg, TV_TRANSLATE)
+              && (value_check_lock(di->di_tv.v_lock, arg_errmsg, TV_TRANSLATE)
                   || var_check_ro(di->di_flags, arg_errmsg, TV_TRANSLATE))) {
             break;
           }
@@ -4899,8 +4899,8 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
       }
       for (listitem_T *li = tv_list_first(l); li != NULL;) {
         if (map
-            && var_check_lock(TV_LIST_ITEM_TV(li)->v_lock, arg_errmsg,
-                              TV_TRANSLATE)) {
+            && value_check_lock(TV_LIST_ITEM_TV(li)->v_lock, arg_errmsg,
+                                TV_TRANSLATE)) {
           break;
         }
         vimvars[VV_KEY].vv_nr = idx;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 6a677dd675..91ab9f14ff 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -362,15 +362,15 @@ static void f_add(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   rettv->vval.v_number = 1;  // Default: failed.
   if (argvars[0].v_type == VAR_LIST) {
     list_T *const l = argvars[0].vval.v_list;
-    if (!var_check_lock(tv_list_locked(l), N_("add() argument"),
-                        TV_TRANSLATE)) {
+    if (!value_check_lock(tv_list_locked(l), N_("add() argument"),
+                          TV_TRANSLATE)) {
       tv_list_append_tv(l, &argvars[1]);
       tv_copy(&argvars[0], rettv);
     }
   } else if (argvars[0].v_type == VAR_BLOB) {
     blob_T *const b = argvars[0].vval.v_blob;
     if (b != NULL
-        && !var_check_lock(b->bv_lock, N_("add() argument"), TV_TRANSLATE)) {
+        && !value_check_lock(b->bv_lock, N_("add() argument"), TV_TRANSLATE)) {
       bool error = false;
       const varnumber_T n = tv_get_number_chk(&argvars[1], &error);
 
@@ -1896,9 +1896,9 @@ static void f_flatten(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   list_T *list = argvars[0].vval.v_list;
   if (list != NULL
-      && !var_check_lock(tv_list_locked(list),
-                         N_("flatten() argument"),
-                         TV_TRANSLATE)
+      && !value_check_lock(tv_list_locked(list),
+                           N_("flatten() argument"),
+                           TV_TRANSLATE)
       && tv_list_flatten(list, maxdepth) == OK) {
     tv_copy(&argvars[0], rettv);
   }
@@ -1915,7 +1915,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
     list_T *const l1 = argvars[0].vval.v_list;
     list_T *const l2 = argvars[1].vval.v_list;
-    if (!var_check_lock(tv_list_locked(l1), arg_errmsg, TV_TRANSLATE)) {
+    if (!value_check_lock(tv_list_locked(l1), arg_errmsg, TV_TRANSLATE)) {
       listitem_T *item;
       if (argvars[2].v_type != VAR_UNKNOWN) {
         long before = (long)tv_get_number_chk(&argvars[2], &error);
@@ -1944,13 +1944,13 @@ static void f_extend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     dict_T *const d1 = argvars[0].vval.v_dict;
     dict_T *const d2 = argvars[1].vval.v_dict;
     if (d1 == NULL) {
-      const bool locked = var_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
+      const bool locked = value_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
       (void)locked;
       assert(locked == true);
     } else if (d2 == NULL) {
       // Do nothing
       tv_copy(&argvars[0], rettv);
-    } else if (!var_check_lock(d1->dv_lock, arg_errmsg, TV_TRANSLATE)) {
+    } else if (!value_check_lock(d1->dv_lock, arg_errmsg, TV_TRANSLATE)) {
       const char *action = "force";
       // Check the third argument.
       if (argvars[2].v_type != VAR_UNKNOWN) {
@@ -3556,8 +3556,8 @@ static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     blob_T *const b = argvars[0].vval.v_blob;
 
     if (b == NULL
-        || var_check_lock(b->bv_lock, N_("insert() argument"),
-                          TV_TRANSLATE)) {
+        || value_check_lock(b->bv_lock, N_("insert() argument"),
+                            TV_TRANSLATE)) {
       return;
     }
 
@@ -3592,8 +3592,8 @@ static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     tv_copy(&argvars[0], rettv);
   } else if (argvars[0].v_type != VAR_LIST) {
     semsg(_(e_listblobarg), "insert()");
-  } else if (!var_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
-                             N_("insert() argument"), TV_TRANSLATE)) {
+  } else if (!value_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
+                               N_("insert() argument"), TV_TRANSLATE)) {
     long before = 0;
     if (argvars[2].v_type != VAR_UNKNOWN) {
       before = tv_get_number_chk(&argvars[2], &error);
@@ -5985,8 +5985,8 @@ static void f_reverse(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     semsg(_(e_listblobarg), "reverse()");
   } else {
     list_T *const l = argvars[0].vval.v_list;
-    if (!var_check_lock(tv_list_locked(l), N_("reverse() argument"),
-                        TV_TRANSLATE)) {
+    if (!value_check_lock(tv_list_locked(l), N_("reverse() argument"),
+                          TV_TRANSLATE)) {
       tv_list_reverse(l);
       tv_list_set_ret(rettv, l);
     }
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 5a356813f0..b48aa1372e 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -900,8 +900,8 @@ void tv_list_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
   list_T *l;
   bool error = false;
 
-  if (var_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
-                     arg_errmsg, TV_TRANSLATE)) {
+  if (value_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
+                       arg_errmsg, TV_TRANSLATE)) {
     return;
   }
 
@@ -1156,7 +1156,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
     semsg(_(e_listarg), sort ? "sort()" : "uniq()");
   } else {
     list_T *const l = argvars[0].vval.v_list;
-    if (var_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE)) {
+    if (value_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE)) {
       goto theend;
     }
     tv_list_set_ret(rettv, l);
@@ -2494,7 +2494,7 @@ void tv_dict_extend(dict_T *const d1, dict_T *const d2, const char *const action
     } else if (*action == 'f' && di2 != di1) {
       typval_T oldtv;
 
-      if (var_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
+      if (value_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
           || var_check_ro(di1->di_flags, arg_errmsg, arg_errmsg_len)) {
         break;
       }
@@ -2710,7 +2710,7 @@ void tv_blob_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
 {
   blob_T *const b = argvars[0].vval.v_blob;
 
-  if (b != NULL && var_check_lock(b->bv_lock, arg_errmsg, TV_TRANSLATE)) {
+  if (b != NULL && value_check_lock(b->bv_lock, arg_errmsg, TV_TRANSLATE)) {
     return;
   }
 
@@ -2902,7 +2902,7 @@ void tv_dict_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
   if (argvars[2].v_type != VAR_UNKNOWN) {
     semsg(_(e_toomanyarg), "remove()");
   } else if ((d = argvars[0].vval.v_dict) != NULL
-             && !var_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE)) {
+             && !value_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE)) {
     const char *key = tv_get_string_chk(&argvars[1]);
     if (key != NULL) {
       dictitem_T *di = tv_dict_find(d, key, -1);
@@ -3460,12 +3460,12 @@ bool tv_check_lock(const typval_T *tv, const char *name, size_t name_len)
   default:
     break;
   }
-  return var_check_lock(tv->v_lock, name, name_len)
-         || (lock != VAR_UNLOCKED && var_check_lock(lock, name, name_len));
+  return value_check_lock(tv->v_lock, name, name_len)
+         || (lock != VAR_UNLOCKED && value_check_lock(lock, name, name_len));
 }
 
-/// @return true if variable "name" is locked (immutable)
-bool var_check_lock(VarLockStatus lock, const char *name, size_t name_len)
+/// @return true if variable "name" has a locked (immutable) value
+bool value_check_lock(VarLockStatus lock, const char *name, size_t name_len)
 {
   const char *error_message = NULL;
   switch (lock) {
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 1d27826e7a..74d9e30a58 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -2551,13 +2551,13 @@ void ex_function(exarg_T *eap)
       goto erret;
     }
     if (fudi.fd_di == NULL) {
-      if (var_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
-                         TV_CSTRING)) {
+      if (value_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
+                           TV_CSTRING)) {
         // Can't add a function to a locked dictionary
         goto erret;
       }
-    } else if (var_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg,
-                              TV_CSTRING)) {
+    } else if (value_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg,
+                                TV_CSTRING)) {
       // Can't change an existing function if it is locked
       goto erret;
     }
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 75af99fbd5..3e593151fc 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -877,13 +877,13 @@ static int do_unlet_var(lval_T *lp, char *name_end, exarg_T *eap, int deep FUNC_
   } else if ((lp->ll_list != NULL
               // ll_list is not NULL when lvalue is not in a list, NULL lists
               // yield E689.
-              && var_check_lock(tv_list_locked(lp->ll_list),
-                                lp->ll_name,
-                                lp->ll_name_len))
+              && value_check_lock(tv_list_locked(lp->ll_list),
+                                  lp->ll_name,
+                                  lp->ll_name_len))
              || (lp->ll_dict != NULL
-                 && var_check_lock(lp->ll_dict->dv_lock,
-                                   lp->ll_name,
-                                   lp->ll_name_len))) {
+                 && value_check_lock(lp->ll_dict->dv_lock,
+                                     lp->ll_name,
+                                     lp->ll_name_len))) {
     return FAIL;
   } else if (lp->ll_range) {
     assert(lp->ll_list != NULL);
@@ -892,9 +892,9 @@ static int do_unlet_var(lval_T *lp, char *name_end, exarg_T *eap, int deep FUNC_
     listitem_T *last_li = first_li;
     for (;;) {
       listitem_T *const li = TV_LIST_ITEM_NEXT(lp->ll_list, lp->ll_li);
-      if (var_check_lock(TV_LIST_ITEM_TV(lp->ll_li)->v_lock,
-                         lp->ll_name,
-                         lp->ll_name_len)) {
+      if (value_check_lock(TV_LIST_ITEM_TV(lp->ll_li)->v_lock,
+                           lp->ll_name,
+                           lp->ll_name_len)) {
         return false;
       }
       lp->ll_li = li;
@@ -976,11 +976,11 @@ int do_unlet(const char *const name, const size_t name_len, const bool forceit)
       dictitem_T *const di = TV_DICT_HI2DI(hi);
       if (var_check_fixed(di->di_flags, name, TV_CSTRING)
           || var_check_ro(di->di_flags, name, TV_CSTRING)
-          || var_check_lock(d->dv_lock, name, TV_CSTRING)) {
+          || value_check_lock(d->dv_lock, name, TV_CSTRING)) {
         return FAIL;
       }
 
-      if (var_check_lock(d->dv_lock, name, TV_CSTRING)) {
+      if (value_check_lock(d->dv_lock, name, TV_CSTRING)) {
         return FAIL;
       }
 
@@ -1023,10 +1023,6 @@ static int do_lock_var(lval_T *lp, char *name_end FUNC_ATTR_UNUSED, exarg_T *eap
   bool lock = eap->cmdidx == CMD_lockvar;
   int ret = OK;
 
-  if (deep == 0) {  // Nothing to do.
-    return OK;
-  }
-
   if (lp->ll_tv == NULL) {
     if (*lp->ll_name == '$') {
       semsg(_(e_lock_unlock), lp->ll_name);
@@ -1050,9 +1046,13 @@ static int do_lock_var(lval_T *lp, char *name_end FUNC_ATTR_UNUSED, exarg_T *eap
         } else {
           di->di_flags &= (uint8_t)(~DI_FLAGS_LOCK);
         }
-        tv_item_lock(&di->di_tv, deep, lock, false);
+        if (deep != 0) {
+          tv_item_lock(&di->di_tv, deep, lock, false);
+        }
       }
     }
+  } else if (deep == 0) {
+    // nothing to do
   } else if (lp->ll_range) {
     listitem_T *li = lp->ll_li;
 
@@ -1282,12 +1282,18 @@ void set_var_const(const char *name, const size_t name_len, typval_T *const tv,
       return;
     }
 
-    // existing variable, need to clear the value
+    // Check in this order for backwards compatibility:
+    // - Whether the variable is read-only
+    // - Whether the variable value is locked
+    // - Whether the variable is locked
     if (var_check_ro(v->di_flags, name, name_len)
-        || var_check_lock(v->di_tv.v_lock, name, name_len)) {
+        || value_check_lock(v->di_tv.v_lock, name, name_len)
+        || var_check_lock(v->di_flags, name, name_len)) {
       return;
     }
 
+    // existing variable, need to clear the value
+
     // Handle setting internal v: variables separately where needed to
     // prevent changing the type.
     if (is_vimvarht(ht)) {
@@ -1418,6 +1424,26 @@ bool var_check_ro(const int flags, const char *name, size_t name_len)
   return true;
 }
 
+/// Return true if di_flags "flags" indicates variable "name" is locked.
+/// Also give an error message.
+bool var_check_lock(const int flags, const char *name, size_t name_len)
+{
+  if (!(flags & DI_FLAGS_LOCK)) {
+    return false;
+  }
+
+  if (name_len == TV_TRANSLATE) {
+    name = _(name);
+    name_len = strlen(name);
+  } else if (name_len == TV_CSTRING) {
+    name_len = strlen(name);
+  }
+
+  semsg(_("E1122: Variable is locked: %*s"), (int)name_len, name);
+
+  return true;
+}
+
 /// Check whether variable is fixed (DI_FLAGS_FIX)
 ///
 /// Also gives an error message.
diff --git a/src/nvim/testdir/test_const.vim b/src/nvim/testdir/test_const.vim
index 7f19085b16..4a6c8779dd 100644
--- a/src/nvim/testdir/test_const.vim
+++ b/src/nvim/testdir/test_const.vim
@@ -194,6 +194,14 @@ func Test_lockvar()
 
   if 0 | lockvar x | endif
   let x = 'again'
+
+  let val = [1, 2, 3]
+  lockvar 0 val
+  let val[0] = 9
+  call assert_equal([9, 2, 3], val)
+  call add(val, 4)
+  call assert_equal([9, 2, 3, 4], val)
+  call assert_fails('let val = [4, 5, 6]', 'E1122:')
 endfunc
 
 
diff --git a/src/nvim/testdir/test_listdict.vim b/src/nvim/testdir/test_listdict.vim
index 8d7bede403..9ecd83265a 100644
--- a/src/nvim/testdir/test_listdict.vim
+++ b/src/nvim/testdir/test_listdict.vim
@@ -357,7 +357,7 @@ endfunc
 " Locked variables
 func Test_list_locked_var()
   let expected = [
-	      \ [['0000-000', 'ppppppp'],
+	      \ [['1000-000', 'ppppppF'],
 	      \  ['0000-000', 'ppppppp'],
 	      \  ['0000-000', 'ppppppp']],
 	      \ [['1000-000', 'ppppppF'],
@@ -384,7 +384,7 @@ func Test_list_locked_var()
         exe "unlockvar " . depth . " l"
       endif
       let ps = islocked("l").islocked("l[1]").islocked("l[1][1]").islocked("l[1][1][0]").'-'.islocked("l[2]").islocked("l[2]['6']").islocked("l[2]['6'][7]")
-      call assert_equal(expected[depth][u][0], ps)
+      call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
       let ps = ''
       try
         let l[1][1][0] = 99
@@ -428,7 +428,7 @@ func Test_list_locked_var()
       catch
         let ps .= 'F'
       endtry
-      call assert_equal(expected[depth][u][1], ps)
+      call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth)
     endfor
   endfor
   call assert_fails("let x=islocked('a b')", 'E488:')
@@ -441,7 +441,7 @@ endfunc
 " Unletting locked variables
 func Test_list_locked_var_unlet()
   let expected = [
-	      \ [['0000-000', 'ppppppp'],
+	      \ [['1000-000', 'ppppppp'],
 	      \  ['0000-000', 'ppppppp'],
 	      \  ['0000-000', 'ppppppp']],
 	      \ [['1000-000', 'ppFppFp'],
@@ -469,7 +469,7 @@ func Test_list_locked_var_unlet()
         exe "unlockvar " . depth . " l"
       endif
       let ps = islocked("l").islocked("l[1]").islocked("l[1][1]").islocked("l[1][1][0]").'-'.islocked("l[2]").islocked("l[2]['6']").islocked("l[2]['6'][7]")
-      call assert_equal(expected[depth][u][0], ps)
+      call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
       let ps = ''
       try
         unlet l[2]['6'][7]
@@ -673,6 +673,9 @@ func Test_func_arg_list()
   call s:arg_list_test(1, 2, [3, 4], {5: 6})
 endfunc
 
+func Test_dict_item_locked()
+endfunc
+
 " Tests for reverse(), sort(), uniq()
 func Test_reverse_sort_uniq()
   let l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5]
diff --git a/test/functional/legacy/055_list_and_dict_types_spec.lua b/test/functional/legacy/055_list_and_dict_types_spec.lua
index c0ff3ed17a..75294b3786 100644
--- a/test/functional/legacy/055_list_and_dict_types_spec.lua
+++ b/test/functional/legacy/055_list_and_dict_types_spec.lua
@@ -330,214 +330,6 @@ describe('list and dictionary types', function()
       same list: 1]])
   end)
 
-  it('locked variables (part 1)', function()
-    source([=[
-      let l = []
-      for depth in range(5)
-	      $put ='depth is ' . depth
-	      for u in range(3)
-	        unlet l
-	        let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}]
-	        exe "lockvar " . depth . " l"
-	        if u == 1
-	          exe "unlockvar l"
-	        elseif u == 2
-	          exe "unlockvar " . depth . " l"
-	        endif
-	        let ps = islocked("l") . islocked("l[1]") . islocked("l[1][1]") .
-	          \ islocked("l[1][1][0]") . '-' . islocked("l[2]") .
-	          \ islocked("l[2]['6']") . islocked("l[2]['6'][7]")
-	        $put =ps
-	        let ps = ''
-	        try
-	          let l[1][1][0] = 99
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l[1][1] = [99]
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l[1] = [99]
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l[2]['6'][7] = 99
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l[2][6] = {99: 99}
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l[2] = {99: 99}
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        try
-	          let l = [99]
-	          let ps .= 'p'
-	        catch
-	          let ps .= 'F'
-	        endtry
-	        $put =ps
-	      endfor
-      endfor]=])
-    expect([[
-
-      depth is 0
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 1
-      1000-000
-      ppppppF
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 2
-      1100-100
-      ppFppFF
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 3
-      1110-110
-      pFFpFFF
-      0010-010
-      pFppFpp
-      0000-000
-      ppppppp
-      depth is 4
-      1111-111
-      FFFFFFF
-      0011-011
-      FFpFFpp
-      0000-000
-      ppppppp]])
-  end)
-
-  -- TODO In the original test the 5th line of this source() call was used.
-  -- But now the test only passes if I comment it.
-  it('unletting locked variables', function()
-    source([=[
-      let l = []
-      for depth in range(5)
-        $put ='depth is ' . depth
-        for u in range(3)
-          "unlet l
-          let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}]
-          exe "lockvar " . depth . " l"
-          if u == 1
-            exe "unlockvar l"
-          elseif u == 2
-            exe "unlockvar " . depth . " l"
-          endif
-          let ps = islocked("l") . islocked("l[1]") . islocked("l[1][1]") .
-	          \ islocked("l[1][1][0]") . '-' . islocked("l[2]") .
-	          \ islocked("l[2]['6']") . islocked("l[2]['6'][7]")
-          $put =ps
-          let ps = ''
-          try
-            unlet l[2]['6'][7]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l[2][6]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l[2]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l[1][1][0]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l[1][1]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l[1]
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          try
-            unlet l
-            let ps .= 'p'
-          catch
-            let ps .= 'F'
-          endtry
-          $put =ps
-        endfor
-      endfor]=])
-    expect([[
-
-      depth is 0
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 1
-      1000-000
-      ppFppFp
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 2
-      1100-100
-      pFFpFFp
-      0000-000
-      ppppppp
-      0000-000
-      ppppppp
-      depth is 3
-      1110-110
-      FFFFFFp
-      0010-010
-      FppFppp
-      0000-000
-      ppppppp
-      depth is 4
-      1111-111
-      FFFFFFp
-      0011-011
-      FppFppp
-      0000-000
-      ppppppp]])
-  end)
-
   it('locked variables and :unlet or list / dict functions', function()
     source([[
       $put ='Locks and commands or functions:'
@@ -676,30 +468,6 @@ describe('list and dictionary types', function()
       ['a', 'b', 3]]=])
   end)
 
-  it('locked variables (part 2)', function()
-    feed_command(
-      'let l = [1, 2, 3, 4]',
-      'lockvar! l',
-      '$put =string(l)',
-      'unlockvar l[1]',
-      'unlet l[0:1]',
-      '$put =string(l)',
-      'unlet l[1:2]',
-      '$put =string(l)',
-      'unlockvar l[1]',
-      'let l[0:1] = [0, 1]',
-      '$put =string(l)',
-      'let l[1:2] = [0, 1]',
-      '$put =string(l)')
-    expect([=[
-
-      [1, 2, 3, 4]
-      [1, 2, 3, 4]
-      [1, 2, 3, 4]
-      [1, 2, 3, 4]
-      [1, 2, 3, 4]]=])
-  end)
-
   it(':lockvar/islocked() triggering script autoloading.', function()
     source([[           
       set rtp+=test/functional/fixtures
diff --git a/test/unit/eval/typval_spec.lua b/test/unit/eval/typval_spec.lua
index 1d13aeca9f..128625374e 100644
--- a/test/unit/eval/typval_spec.lua
+++ b/test/unit/eval/typval_spec.lua
@@ -2625,7 +2625,7 @@ describe('typval.c', function()
     describe('check_lock()', function()
       local function tv_check_lock(lock, name, name_len, emsg)
         return check_emsg(function()
-          return lib.var_check_lock(lock, name, name_len)
+          return lib.value_check_lock(lock, name, name_len)
         end, emsg)
       end
       itp('works', function()