aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-09-19 03:03:50 -04:00
Code

patch 8.2.3991: Vim9: error when extending dict<any>

Browse Source 
Problem:    Vim9: error when extending dict<any> with another type that it was
            initialized with.
Solution:   Also set the type for dict<any> if the initializer has a more
            specific type. (closes #9461)
This commit is contained in:
Bram Moolenaar 2022-01-03 12:28:03 +00:00
parent 5c75eed758
commit 114dbda785
10 changed files with 66 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/eval.c
View File

@ -3328,7 +3328,8 @@ eval7t(
{
if (res == OK)
{
type_T *actual = typval2type(rettv, get_copyID(), &type_list, TRUE);
type_T *actual = typval2type(rettv, get_copyID(), &type_list,
TVTT_DO_MEMBER);
if (!equal_type(want_type, actual, 0))
{

6
src/list.c
View File

@ -2478,7 +2478,7 @@ filter_map(typval_T *argvars, typval_T *rettv, filtermap_T filtermap)
{
// Check that map() does not change the type of the dict.
ga_init2(&type_list, sizeof(type_T *), 10);
type = typval2type(argvars, get_copyID(), &type_list, TRUE);
type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
}
if (argvars[0].v_type != VAR_BLOB
@ -2763,9 +2763,9 @@ extend(typval_T *argvars, typval_T *rettv, char_u *arg_errmsg, int is_new)
if (!is_new && in_vim9script())
{
// Check that map() does not change the type of the dict.
// Check that extend() does not change the type of the dict.
ga_init2(&type_list, sizeof(type_T *), 10);
type = typval2type(argvars, get_copyID(), &type_list, TRUE);
type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
}
if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)

8
src/testdir/test_vim9_assign.vim
View File

@ -757,6 +757,10 @@ def Test_assignment_list()
# type becomes list<any>
var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
# type is list<any> even though initializer is list<number>
var anyList: list<any> = [0]
assert_equal([0, 'x'], extend(anyList, ['x']))
var lines =<< trim END
var d = {dd: test_null_list()}
d.dd[0] = 0
@ -955,6 +959,10 @@ def Test_assignment_dict()
# type becomes dict<any>
var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
# type is dict<any> even though initializer is dict<number>
var anyDict: dict<any> = {a: 0}
assert_equal({a: 0, b: 'x'}, extend(anyDict, {b: 'x'}))
# assignment to script-local dict
lines =<< trim END
vim9script

5
src/testdir/test_vim9_builtin.vim
View File

@ -2143,6 +2143,11 @@ def Test_map()
CheckDefAndScriptFailure(['map(test_null_channel(), "1")'], ['E1013: Argument 1: type mismatch, expected list<any> but got channel', 'E1251: List, Dictionary, Blob or String required for argument 1'])
endif
CheckDefAndScriptFailure(['map(1, "1")'], ['E1013: Argument 1: type mismatch, expected list<any> but got number', 'E1251: List, Dictionary, Blob or String required for argument 1'])
# type of dict remains dict<any> even when type of values changes
var d: dict<any> = {a: 0}
d->map((k, v) => true)
d->map((k, v) => 'x')
enddef
def Test_map_failure()

7
src/testdir/test_vim9_func.vim
View File

@ -439,6 +439,8 @@ def Test_return_invalid()
enddef
def Test_return_list_any()
# This used to fail but now the actual list type is checked, and since it has
# an item of type string it can be used as list<string>.
var lines =<< trim END
vim9script
def Func(): list<string>
@ -448,7 +450,8 @@ def Test_return_list_any()
enddef
echo Func()
END
CheckScriptFailure(lines, 'E1012:')
CheckScriptSuccess(lines)
lines =<< trim END
vim9script
def Func(): list<string>
@ -458,7 +461,7 @@ def Test_return_list_any()
enddef
echo Func()
END
CheckScriptFailure(lines, 'E1012:')
CheckScriptSuccess(lines)
enddef
func Increment()

2
src/version.c
View File

@ -750,6 +750,8 @@ static char *(features[]) =
static int included_patches[] =
{ /* Add new patch number below this line */
/**/
3991,
/**/
3990,
/**/

4
src/vim9.h
View File

@ -725,3 +725,7 @@ struct cctx_S {
// lhs_name is not NULL
};
// flags for typval2type()
#define TVTT_DO_MEMBER 1
#define TVTT_MORE_SPECIFIC 2 // get most specific type for member

5
src/vim9compile.c
View File

@ -2286,11 +2286,6 @@ compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
&& (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_any
&& oplen > 0
&& rhs_type != NULL
&& rhs_type->tt_type == lhs.lhs_type->tt_type
&& rhs_type->tt_member != &t_unknown)
&& 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<any> = val", then the

3
src/vim9script.c
View File

@ -907,7 +907,8 @@ update_vim9_script_var(
if (sv != NULL)
{
if (*type == NULL)
*type = typval2type(tv, get_copyID(), &si->sn_type_list, do_member);
*type = typval2type(tv, get_copyID(), &si->sn_type_list,
do_member ? TVTT_DO_MEMBER : 0);
if (sv->sv_type_allocated)
free_type(sv->sv_type);
if (*type != NULL && ((*type)->tt_type == VAR_FUNC

51
src/vim9type.c
View File

@ -252,10 +252,13 @@ func_type_add_arg_types(
/*
* Get a type_T for a typval_T.
* "type_gap" is used to temporarily create types in.
* When "do_member" is TRUE also get the member type, otherwise use "any".
* When "flags" has TVTT_DO_MEMBER also get the member type, otherwise use
* "any".
* When "flags" has TVTT_MORE_SPECIFIC get the more specific member type if it
* is "any".
*/
static type_T *
typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int flags)
{
type_T *type;
type_T *member_type = NULL;
@ -278,9 +281,13 @@ typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
if (l == NULL || (l->lv_first == NULL && l->lv_type == NULL))
return &t_list_empty;
if (!do_member)
if ((flags & TVTT_DO_MEMBER) == 0)
return &t_list_any;
if (l->lv_type != NULL)
// If the type is list<any> go through the members, it may end up a
// more specific type.
if (l->lv_type != NULL && (l->lv_first == NULL
|| (flags & TVTT_MORE_SPECIFIC) == 0
|| l->lv_type->tt_member != &t_any))
return l->lv_type;
if (l->lv_first == &range_list_item)
return &t_list_number;
@ -290,9 +297,11 @@ typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
l->lv_copyID = copyID;
// Use the common type of all members.
member_type = typval2type(&l->lv_first->li_tv, copyID, type_gap, TRUE);
member_type = typval2type(&l->lv_first->li_tv, copyID, type_gap,
TVTT_DO_MEMBER);
for (li = l->lv_first->li_next; li != NULL; li = li->li_next)
common_type(typval2type(&li->li_tv, copyID, type_gap, TRUE),
common_type(typval2type(&li->li_tv, copyID, type_gap,
TVTT_DO_MEMBER),
member_type, &member_type, type_gap);
return get_list_type(member_type, type_gap);
}
@ -305,9 +314,13 @@ typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
if (d == NULL || (d->dv_hashtab.ht_used == 0 && d->dv_type == NULL))
return &t_dict_empty;
if (!do_member)
if ((flags & TVTT_DO_MEMBER) == 0)
return &t_dict_any;
if (d->dv_type != NULL)
// If the type is dict<any> go through the members, it may end up a
// more specific type.
if (d->dv_type != NULL && (d->dv_hashtab.ht_used == 0
|| (flags & TVTT_MORE_SPECIFIC) == 0
|| d->dv_type->tt_member != &t_any))
return d->dv_type;
if (d->dv_copyID == copyID)
// avoid recursion
@ -317,9 +330,9 @@ typval2type_int(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
// Use the common type of all values.
dict_iterate_start(tv, &iter);
dict_iterate_next(&iter, &value);
member_type = typval2type(value, copyID, type_gap, TRUE);
member_type = typval2type(value, copyID, type_gap, TVTT_DO_MEMBER);
while (dict_iterate_next(&iter, &value) != NULL)
common_type(typval2type(value, copyID, type_gap, TRUE),
common_type(typval2type(value, copyID, type_gap, TVTT_DO_MEMBER),
member_type, &member_type, type_gap);
return get_dict_type(member_type, type_gap);
}
@ -424,12 +437,14 @@ need_convert_to_bool(type_T *type, typval_T *tv)
/*
* Get a type_T for a typval_T.
* "type_list" is used to temporarily create types in.
* When "do_member" is TRUE also get the member type, otherwise use "any".
* When "flags" has TVTT_DO_MEMBER also get the member type, otherwise use
* "any".
* When "flags" has TVTT_MORE_SPECIFIC get the most specific member type.
*/
type_T *
typval2type(typval_T *tv, int copyID, garray_T *type_gap, int do_member)
typval2type(typval_T *tv, int copyID, garray_T *type_gap, int flags)
{
type_T *type = typval2type_int(tv, copyID, type_gap, do_member);
type_T *type = typval2type_int(tv, copyID, type_gap, flags);
if (type != NULL && type != &t_bool
&& (tv->v_type == VAR_NUMBER
@ -451,7 +466,7 @@ typval2type_vimvar(typval_T *tv, garray_T *type_gap)
return &t_list_string;
if (tv->v_type == VAR_DICT) // e.g. for v:completed_item
return &t_dict_any;
return typval2type(tv, get_copyID(), type_gap, TRUE);
return typval2type(tv, get_copyID(), type_gap, TVTT_DO_MEMBER);
}
int
@ -493,7 +508,11 @@ check_typval_type(type_T *expected, typval_T *actual_tv, where_T where)
}
ga_init2(&type_list, sizeof(type_T *), 10);
actual_type = typval2type(actual_tv, get_copyID(), &type_list, TRUE);
// When the actual type is list<any> or dict<any> go through the values to
// possibly get a more specific type.
actual_type = typval2type(actual_tv, get_copyID(), &type_list,
TVTT_DO_MEMBER | TVTT_MORE_SPECIFIC);
if (actual_type != NULL)
{
res = check_type_maybe(expected, actual_type, TRUE, where);
@ -1346,7 +1365,7 @@ f_typename(typval_T *argvars, typval_T *rettv)
rettv->v_type = VAR_STRING;
ga_init2(&type_list, sizeof(type_T *), 10);
type = typval2type(argvars, get_copyID(), &type_list, TRUE);
type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
name = type_name(type, &tofree);
if (tofree != NULL)
rettv->vval.v_string = (char_u *)tofree;