# HG changeset patch # User Bram Moolenaar # Date 1641312004 -3600 # Node ID 7045e9308ca3b5983d10982f50428febdd30140c # Parent 6b6a26145714e68119b8af00434c6bb71ae068c0 patch 8.2.3997: Vim9: not enough testing for extend() and map() Commit: https://github.com/vim/vim/commit/10d6f18b2f9090d19dd884827c4be59a20b446bf Author: Bram Moolenaar Date: Tue Jan 4 15:54:38 2022 +0000 patch 8.2.3997: Vim9: not enough testing for extend() and map() Problem: Vim9: not enough testing for extend() and map(). Solution: Add more test cases. Fix uncovered problems. Remove unused type fields. diff --git a/src/dict.c b/src/dict.c --- a/src/dict.c +++ b/src/dict.c @@ -109,8 +109,6 @@ dict_free_contents(dict_T *d) hashtab_free_contents(&d->dv_hashtab); free_type(d->dv_type); d->dv_type = NULL; - free_type(d->dv_decl_type); - d->dv_decl_type = NULL; } /* diff --git a/src/list.c b/src/list.c --- a/src/list.c +++ b/src/list.c @@ -271,7 +271,6 @@ list_free_list(list_T *l) l->lv_used_next->lv_used_prev = l->lv_used_prev; free_type(l->lv_type); - free_type(l->lv_decl_type); vim_free(l); } @@ -1026,8 +1025,6 @@ flatten_common(typval_T *argvars, typval // The type will change. free_type(l->lv_type); l->lv_type = NULL; - free_type(l->lv_decl_type); - l->lv_decl_type = NULL; } else { @@ -1223,7 +1220,6 @@ list_copy(list_T *orig, int deep, int co if (copy != NULL) { copy->lv_type = alloc_type(orig->lv_type); - copy->lv_decl_type = alloc_type(orig->lv_decl_type); if (copyID != 0) { // Do this before adding the items, because one of the items may diff --git a/src/structs.h b/src/structs.h --- a/src/structs.h +++ b/src/structs.h @@ -1513,7 +1513,6 @@ struct listvar_S } mat; } lv_u; type_T *lv_type; // current type, allocated by alloc_type() - type_T *lv_decl_type; // declared type, allocated by alloc_type() list_T *lv_copylist; // copied list used by deepcopy() list_T *lv_used_next; // next list in used lists list list_T *lv_used_prev; // previous list in used lists list @@ -1578,7 +1577,6 @@ struct dictvar_S int dv_copyID; // ID used by deepcopy() hashtab_T dv_hashtab; // hashtab that refers to the items type_T *dv_type; // current type, allocated by alloc_type() - type_T *dv_decl_type; // declared type, allocated by alloc_type() dict_T *dv_copydict; // copied dict used by deepcopy() dict_T *dv_used_next; // next dict in used dicts list dict_T *dv_used_prev; // previous dict in used dicts list diff --git a/src/testdir/test_vim9_builtin.vim b/src/testdir/test_vim9_builtin.vim --- a/src/testdir/test_vim9_builtin.vim +++ b/src/testdir/test_vim9_builtin.vim @@ -979,6 +979,10 @@ def Test_extend_arg_types() var res: list> extend(res, mapnew([1, 2], (_, v) => ({}))) assert_equal([{}, {}], res) + + var dany: dict = {a: 0} + dany->extend({b: 'x'}) + assert_equal({a: 0, b: 'x'}, dany) END CheckDefAndScriptSuccess(lines) @@ -2151,9 +2155,29 @@ def Test_map() CheckDefAndScriptFailure(['map(1, "1")'], ['E1013: Argument 1: type mismatch, expected list but got number', 'E1251: List, Dictionary, Blob or String required for argument 1']) # type of dict remains dict even when type of values changes - var d: dict = {a: 0} - d->map((k, v) => true) - d->map((k, v) => 'x') + # same for list + var lines =<< trim END + var d: dict = {a: 0} + d->map((k, v) => true) + d->map((k, v) => 'x') + assert_equal({a: 'x'}, d) + + d = {a: 0} + g:gd = d + map(g:gd, (k, v) => true) + assert_equal({a: true}, g:gd) + + var l: list = [0] + l->map((k, v) => true) + l->map((k, v) => 'x') + assert_equal(['x'], l) + + l = [1] + g:gl = l + map(g:gl, (k, v) => true) + assert_equal([true], g:gl) + END + CheckDefAndScriptSuccess(lines) enddef def Test_map_failure() @@ -2175,6 +2199,13 @@ def Test_map_failure() CheckScriptFailure(lines, 'E1013:') au! BufReadPost delete('Xtmpfile') + + lines =<< trim END + var d: dict = {a: 1} + g:gd = d + map(g:gd, (k, v) => true) + END + CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got bool') enddef def Test_map_function_arg() diff --git a/src/testdir/test_vim9_disassemble.vim b/src/testdir/test_vim9_disassemble.vim --- a/src/testdir/test_vim9_disassemble.vim +++ b/src/testdir/test_vim9_disassemble.vim @@ -455,6 +455,7 @@ def Test_disassemble_list_assign() '\d\+ CHECKTYPE string stack\[-1\] arg 2\_s*' .. '\d\+ STORE $1\_s*' .. '\d\+ SLICE 2\_s*' .. + '\d\+ SETTYPE list\_s*' .. '\d\+ STORE $2\_s*' .. '\d\+ RETURN void', res) diff --git a/src/version.c b/src/version.c --- a/src/version.c +++ b/src/version.c @@ -751,6 +751,8 @@ static char *(features[]) = static int included_patches[] = { /* Add new patch number below this line */ /**/ + 3997, +/**/ 3996, /**/ 3995, diff --git a/src/vim9compile.c b/src/vim9compile.c --- a/src/vim9compile.c +++ b/src/vim9compile.c @@ -2279,14 +2279,12 @@ compile_assignment(char_u *arg, exarg_T // ":const var": lock the value, but not referenced variables generate_LOCKCONST(cctx); - if (is_decl - && (lhs.lhs_type->tt_type == VAR_DICT + if ((lhs.lhs_type->tt_type == VAR_DICT || lhs.lhs_type->tt_type == VAR_LIST) && lhs.lhs_type->tt_member != NULL && lhs.lhs_type->tt_member != &t_unknown) // Set the type in the list or dict, so that it can be checked, - // also in legacy script. Not for "list = val", then the - // type of "val" is used. + // also in legacy script. generate_SETTYPE(cctx, lhs.lhs_type); if (!skip_store && generate_store_lhs(cctx, &lhs,