Merge #4112 'vim-patch:7.4.698'

src/nvim/eval.c

@@ -2890,9 +2890,12 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
     else if (do_unlet(lp->ll_name, forceit) == FAIL)
       ret = FAIL;
     *name_end = cc;
-  } else if (tv_check_lock(lp->ll_tv->v_lock, lp->ll_name))
+  } else if ((lp->ll_list != NULL
+              && tv_check_lock(lp->ll_list->lv_lock, lp->ll_name))
+             || (lp->ll_dict != NULL
+                 && tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name))) {
     return FAIL;
-  else if (lp->ll_range) {
+  } else if (lp->ll_range) {
     listitem_T    *li;
     listitem_T *ll_li = lp->ll_li;
     int ll_n1 = lp->ll_n1;
@@ -2953,17 +2956,30 @@ int do_unlet(char_u *name, int forceit)
   hashtab_T   *ht;
   hashitem_T  *hi;
   char_u      *varname;
+  dict_T      *d;
   dictitem_T  *di;
   dict_T *dict;
   ht = find_var_ht_dict(name, &varname, &dict);
 
   if (ht != NULL && *varname != NUL) {
+    if (ht == &globvarht) {
+      d = &globvardict;
+    } else if (current_funccal != NULL
+               && ht == &current_funccal->l_vars.dv_hashtab) {
+      d = &current_funccal->l_vars;
+    } else {
+      di = find_var_in_ht(ht, *name, (char_u *)"", false);
+      d = di->di_tv.vval.v_dict;
+    }
+
     hi = hash_find(ht, varname);
     if (!HASHITEM_EMPTY(hi)) {
       di = HI2DI(hi);
       if (var_check_fixed(di->di_flags, name)
-          || var_check_ro(di->di_flags, name))
+          || var_check_ro(di->di_flags, name)
+          || tv_check_lock(d->dv_lock, name)) {
         return FAIL;
+      }
       typval_T oldtv;
       bool watched = is_watched(dict);
 
@@ -6055,7 +6071,7 @@ dictitem_T *dictitem_alloc(char_u *key) FUNC_ATTR_NONNULL_RET
 #ifndef __clang_analyzer__
   STRCPY(di->di_key, key);
 #endif
-  di->di_flags = 0;
+  di->di_flags = DI_FLAGS_ALLOC;
   return di;
 }
 
@@ -6067,7 +6083,7 @@ static dictitem_T *dictitem_copy(dictitem_T *org) FUNC_ATTR_NONNULL_RET
   dictitem_T *di = xmalloc(sizeof(dictitem_T) + STRLEN(org->di_key));
 
   STRCPY(di->di_key, org->di_key);
-  di->di_flags = 0;
+  di->di_flags = DI_FLAGS_ALLOC;
   copy_tv(&org->di_tv, &di->di_tv);
 
   return di;
@@ -6095,7 +6111,9 @@ static void dictitem_remove(dict_T *dict, dictitem_T *item)
 void dictitem_free(dictitem_T *item)
 {
   clear_tv(&item->di_tv);
-  xfree(item);
+  if (item->di_flags & DI_FLAGS_ALLOC) {
+    xfree(item);
+  }
 }
 
 /// Make a copy of dictionary
@@ -9212,6 +9230,7 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
   hashitem_T  *hi2;
   int todo;
   bool watched = is_watched(d1);
+  char *arg_errmsg = N_("extend() argument");
 
   todo = (int)d2->dv_hashtab.ht_used;
   for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) {
@@ -9245,6 +9264,11 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
       } else if (*action == 'f' && HI2DI(hi2) != di1) {
         typval_T oldtv;
 
+        if (tv_check_lock(di1->di_tv.v_lock, (char_u *)_(arg_errmsg))
+            || var_check_ro(di1->di_flags, (char_u *)_(arg_errmsg))) {
+          break;
+        }
+
         if (watched) {
           copy_tv(&di1->di_tv, &oldtv);
         }
@@ -9460,12 +9484,14 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
 
   if (argvars[0].v_type == VAR_LIST) {
     if ((l = argvars[0].vval.v_list) == NULL
-        || tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg)))
+        || (!map && tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg)))) {
       return;
+    }
   } else if (argvars[0].v_type == VAR_DICT) {
     if ((d = argvars[0].vval.v_dict) == NULL
-        || tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg)))
+        || (!map && tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg)))) {
       return;
+    }
   } else {
     EMSG2(_(e_listdictarg), ermsg);
     return;
@@ -9494,17 +9520,26 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
       for (hi = ht->ht_array; todo > 0; ++hi) {
         if (!HASHITEM_EMPTY(hi)) {
           --todo;
+
           di = HI2DI(hi);
-          if (tv_check_lock(di->di_tv.v_lock,
+          if (map
-                  (char_u *)_(arg_errmsg)))
+              && (tv_check_lock(di->di_tv.v_lock, (char_u *)_(arg_errmsg))
+                  || var_check_ro(di->di_flags, (char_u *)_(arg_errmsg)))) {
             break;
+          }
+
           vimvars[VV_KEY].vv_str = vim_strsave(di->di_key);
           int r = filter_map_one(&di->di_tv, expr, map, &rem);
           clear_tv(&vimvars[VV_KEY].vv_tv);
           if (r == FAIL || did_emsg)
             break;
-          if (!map && rem)
+          if (!map && rem) {
+            if (var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg))
+                || var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) {
+              break;
+            }
             dictitem_remove(d, di);
+          }
         }
       }
       hash_unlock(ht);
@@ -9512,8 +9547,9 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
       vimvars[VV_KEY].vv_type = VAR_NUMBER;
 
       for (li = l->lv_first; li != NULL; li = nli) {
-        if (tv_check_lock(li->li_tv.v_lock, (char_u *)_(arg_errmsg)))
+        if (map && tv_check_lock(li->li_tv.v_lock, (char_u *)_(arg_errmsg))) {
           break;
+        }
         nli = li->li_next;
         vimvars[VV_KEY].vv_nr = idx;
         if (filter_map_one(&li->li_tv, expr, map, &rem) == FAIL
@@ -13878,9 +13914,10 @@ static void f_remove(typval_T *argvars, typval_T *rettv)
       key = get_tv_string_chk(&argvars[1]);
       if (key != NULL) {
         di = dict_find(d, key, -1);
-        if (di == NULL)
+        if (di == NULL) {
           EMSG2(_(e_dictkey), key);
-        else {
+        } else if (!var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg))
+                   && !var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) {
           *rettv = di->di_tv;
           init_tv(&di->di_tv);
           dictitem_remove(d, di);
@@ -18648,14 +18685,16 @@ static void vars_clear_ext(hashtab_T *ht, int free_val)
     if (!HASHITEM_EMPTY(hi)) {
       --todo;
 
-      /* Free the variable.  Don't remove it from the hashtab,
+      // Free the variable.  Don't remove it from the hashtab,
-       * ht_array might change then.  hash_clear() takes care of it
+      // ht_array might change then.  hash_clear() takes care of it
-       * later. */
+      // later.
       v = HI2DI(hi);
-      if (free_val)
+      if (free_val) {
         clear_tv(&v->di_tv);
-      if ((v->di_flags & DI_FLAGS_FIX) == 0)
+      }
+      if (v->di_flags & DI_FLAGS_ALLOC) {
         xfree(v);
+      }
     }
   }
   hash_clear(ht);
@@ -18829,7 +18868,7 @@ set_var (
       xfree(v);
       return;
     }
-    v->di_flags = 0;
+    v->di_flags = DI_FLAGS_ALLOC;
   }
 
   if (copy || tv->v_type == VAR_NUMBER || tv->v_type == VAR_FLOAT) {
@@ -20720,7 +20759,7 @@ call_user_func (
       v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
     } else {
       v = xmalloc(sizeof(dictitem_T) + STRLEN(name));
-      v->di_flags = DI_FLAGS_RO;
+      v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX | DI_FLAGS_ALLOC;
     }
     STRCPY(v->di_key, name);
     hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v));

src/nvim/eval_defs.h

@@ -101,10 +101,11 @@ struct dictitem_S {
 
 typedef struct dictitem_S dictitem_T;
 
-#define DI_FLAGS_RO     1 /* "di_flags" value: read-only variable */
+#define DI_FLAGS_RO     1   // "di_flags" value: read-only variable
-#define DI_FLAGS_RO_SBX 2 /* "di_flags" value: read-only in the sandbox */
+#define DI_FLAGS_RO_SBX 2   // "di_flags" value: read-only in the sandbox
-#define DI_FLAGS_FIX    4 /* "di_flags" value: fixed variable, not allocated */
+#define DI_FLAGS_FIX    4   // "di_flags" value: fixed: no :unlet or remove()
-#define DI_FLAGS_LOCK   8 /* "di_flags" value: locked variable */
+#define DI_FLAGS_LOCK   8   // "di_flags" value: locked variable
+#define DI_FLAGS_ALLOC  16  // "di_flags" value: separately allocated
 
 /*
  * Structure to hold info about a Dictionary.

src/nvim/testdir/test55.in

@@ -282,6 +282,166 @@ let l = [0, 1, 2, 3]
 :    $put =ps
 :  endfor
 :endfor
+:"
+:" Unletting locked variables
+:$put ='Unletting:'
+: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
+:"
+:" Locked variables and :unlet or list / dict functions
+:$put ='Locks and commands or functions:'
+:"
+:$put ='No :unlet after lock on dict:'
+:unlet! d
+:let d = {'a': 99, 'b': 100}
+:lockvar 1 d
+:try
+:  unlet d.a
+:  $put ='did :unlet'
+:catch
+:  $put =v:exception[:16]
+:endtry
+:$put =string(d)
+:"
+:$put =':unlet after lock on dict item:'
+:unlet! d
+:let d = {'a': 99, 'b': 100}
+:lockvar d.a
+:try
+:  unlet d.a
+:  $put ='did :unlet'
+:catch
+:  $put =v:exception[:16]
+:endtry
+:$put =string(d)
+:"
+:$put ='filter() after lock on dict item:'
+:unlet! d
+:let d = {'a': 99, 'b': 100}
+:lockvar d.a
+:try
+:  call filter(d, 'v:key != "a"')
+:  $put ='did filter()'
+:catch
+:  $put =v:exception[:16]
+:endtry
+:$put =string(d)
+:"
+:$put ='map() after lock on dict:'
+:unlet! d
+:let d = {'a': 99, 'b': 100}
+:lockvar 1 d
+:try
+:  call map(d, 'v:val + 200')
+:  $put ='did map()'
+:catch
+:  $put =v:exception[:16]
+:endtry
+:$put =string(d)
+:"
+:$put ='No extend() after lock on dict item:'
+:unlet! d
+:let d = {'a': 99, 'b': 100}
+:lockvar d.a
+:try
+:  $put =string(extend(d, {'a': 123}))
+:  $put ='did extend()'
+:catch
+:  $put =v:exception[:14]
+:endtry
+:$put =string(d)
+:"
+:$put ='No remove() of write-protected scope-level variable:'
+:fun! Tfunc(this_is_a_loooooooooong_parameter_name)
+:  try
+:    $put =string(remove(a:, 'this_is_a_loooooooooong_parameter_name'))
+:    $put ='did remove()'
+:  catch
+:    $put =v:exception[:14]
+:  endtry
+:endfun
+:call Tfunc('testval')
+:"
+:$put ='No extend() of write-protected scope-level variable:'
+:fun! Tfunc(this_is_a_loooooooooong_parameter_name)
+:  try
+:    $put =string(extend(a:, {'this_is_a_loooooooooong_parameter_name': 1234}))
+:    $put ='did extend()'
+:  catch
+:    $put =v:exception[:14]
+:  endtry
+:endfun
+:call Tfunc('testval')
+:"
+:$put ='No :unlet of variable in locked scope:'
+:let b:testvar = 123
+:lockvar 1 b:
+:try
+:  unlet b:testvar
+:  $put ='b:testvar was :unlet: '. (!exists('b:testvar'))
+:catch
+:  $put =v:exception[:16]
+:endtry
+:unlockvar 1 b:
+:unlet! b:testvar
+:"
 :unlet l
 :let l = [1, 2, 3, 4]
 :lockvar! l

src/nvim/testdir/test55.ok

@@ -86,6 +86,64 @@ FFFFFFF
 FFpFFpp
 0000-000
 ppppppp
+Unletting:
+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
+Locks and commands or functions:
+No :unlet after lock on dict:
+Vim(unlet):E741: 
+{'a': 99, 'b': 100}
+:unlet after lock on dict item:
+did :unlet
+{'b': 100}
+filter() after lock on dict item:
+did filter()
+{'b': 100}
+map() after lock on dict:
+did map()
+{'a': 299, 'b': 300}
+No extend() after lock on dict item:
+Vim(put):E741: 
+{'a': 99, 'b': 100}
+No remove() of write-protected scope-level variable:
+Vim(put):E795: 
+No extend() of write-protected scope-level variable:
+Vim(put):E742: 
+No :unlet of variable in locked scope:
+Vim(unlet):E741: 
 [1, 2, 3, 4]
 [1, 2, 3, 4]
 [1, 2, 3, 4]

src/nvim/version.c

@@ -426,7 +426,7 @@ static int included_patches[] = {
   // 701 NA
   // 700,
   699,
-  // 698,
+  698,
   // 697,
   696,
   695,