patch 8.2.3991: Vim9: error when extending dict<any>v8.2.3991

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)

10 files changed, 66 insertions, 28 deletions

diff --git a/src/eval.c b/src/eval.c
index 99bc5a577..0fb79112d 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -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))
 	    {
diff --git a/src/list.c b/src/list.c
index 743ccf519..6b275789d 100644
--- a/src/list.c
+++ b/src/list.c
@@ -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)
diff --git a/src/testdir/test_vim9_assign.vim b/src/testdir/test_vim9_assign.vim
index 683180995..223a6e401 100644
--- a/src/testdir/test_vim9_assign.vim
+++ b/src/testdir/test_vim9_assign.vim
@@ -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
diff --git a/src/testdir/test_vim9_builtin.vim b/src/testdir/test_vim9_builtin.vim
index 2ee1a9344..df27dba6f 100644
--- a/src/testdir/test_vim9_builtin.vim
+++ b/src/testdir/test_vim9_builtin.vim
@@ -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()
diff --git a/src/testdir/test_vim9_func.vim b/src/testdir/test_vim9_func.vim
index 1cdf7d480..0ec1700dc 100644
--- a/src/testdir/test_vim9_func.vim
+++ b/src/testdir/test_vim9_func.vim
@@ -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()
diff --git a/src/version.c b/src/version.c
index 6ad109033..96864ef31 100644
--- 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 */
 /**/
+    3991,
+/**/
     3990,
 /**/
     3989,
diff --git a/src/vim9.h b/src/vim9.h
index d2c23be01..2ae3f4208 100644
--- a/src/vim9.h
+++ b/src/vim9.h
@@ -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
+
diff --git a/src/vim9compile.c b/src/vim9compile.c
index 51cb44d54..026b18f39 100644
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -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
diff --git a/src/vim9script.c b/src/vim9script.c
index ab6557073..12c266a27 100644
--- a/src/vim9script.c
+++ b/src/vim9script.c
@@ -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
diff --git a/src/vim9type.c b/src/vim9type.c
index c6e80e677..d07c6e6a0 100644
--- a/src/vim9type.c
+++ b/src/vim9type.c
@@ -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;