patch 8.2.1272: Vim9: type not checked if declaration also assigns value

Problem:    Vim9: type not checked if declaration also assigns value.
Solution:   Check the type. (issue #6507)

diff --git a/src/eval.c b/src/eval.c
index c3f0ee5c9f88af3eeccc2b823692a2a8c9d5f107..a8e388db01fea1919a033c5d1284cc78aa255fc8 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -1270,7 +1270,12 @@ set_var_lval(
            }
        }
        else
+       {
+           if (lp->ll_type != NULL
+                             && check_typval_type(lp->ll_type, rettv) == FAIL)
+               return;
            set_var_const(lp->ll_name, lp->ll_type, rettv, copy, flags);
+       }
        *endp = cc;
     }
     else if (var_check_lock(lp->ll_newkey == NULL

diff --git a/src/proto/vim9compile.pro b/src/proto/vim9compile.pro
index 30f7bbfb0e306aae3a853b5b87a4b012a8dd84a6..6bf3eb315d3d05af1c3bd2ee271a64d800811a46 100644 (file)
--- a/src/proto/vim9compile.pro
+++ b/src/proto/vim9compile.pro
@@ -1,9 +1,10 @@
 /* vim9compile.c */
 int check_defined(char_u *p, size_t len, cctx_T *cctx);
 void clear_type_list(garray_T *gap);
-type_T *typval2type(typval_T *tv);
+type_T *typval2type(typval_T *tv, garray_T *type_gap);
+type_T *typval2type_vimvar(typval_T *tv, garray_T *type_gap);
+int check_typval_type(type_T *expected, typval_T *actual_tv);
 int check_type(type_T *expected, type_T *actual, int give_msg);
-int check_argtype(type_T *expected, typval_T *actual_tv);
 int check_compare_types(exptype_T type, typval_T *tv1, typval_T *tv2);
 char_u *skip_type(char_u *start);
 type_T *parse_type(char_u **arg, garray_T *type_gap);

diff --git a/src/testdir/test_vim9_script.vim b/src/testdir/test_vim9_script.vim
index 5fec8a2746f927f34201e6602a78b76b77da02a4..36d7e89c73c08d339da7214b90276dc6cd2b1de5 100644 (file)
--- a/src/testdir/test_vim9_script.vim
+++ b/src/testdir/test_vim9_script.vim
@@ -29,6 +29,9 @@ def Test_assignment()
   call CheckDefFailure(['let x:string = "x"'], 'E1069:')
   call CheckDefFailure(['let a:string = "x"'], 'E1069:')
 
+  let nr: number = 1234
+  call CheckDefFailure(['let nr: number = "asdf"'], 'E1013:')
+
   let a: number = 6 #comment
   assert_equal(6, a)
 

diff --git a/src/version.c b/src/version.c
index 0bb6b0a75e313025976c6014ddadcd768cbf29b2..36951df40e5ebc722436533872d38b68cb11dadc 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -754,6 +754,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1272,
 /**/
     1271,
 /**/

diff --git a/src/vim9compile.c b/src/vim9compile.c
index 999833b5221d530d8c4469a5d0731bbb0a581596..fa7171c8a4ed6b8218e3dbd299cfd2b19f06b3b1 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -478,22 +478,106 @@ func_type_add_arg_types(
 }
 
 /*
- * Return the type_T for a typval.  Only for primitive types.
+ * Get a type_T for a typval_T.
+ * "type_list" is used to temporarily create types in.
  */
     type_T *
-typval2type(typval_T *tv)
+typval2type(typval_T *tv, garray_T *type_gap)
 {
+    type_T  *actual;
+    type_T  *member_type;
+
     if (tv->v_type == VAR_NUMBER)
        return &t_number;
     if (tv->v_type == VAR_BOOL)
        return &t_bool;  // not used
     if (tv->v_type == VAR_STRING)
        return &t_string;
+
+    if (tv->v_type == VAR_LIST
+           && tv->vval.v_list != NULL
+           && tv->vval.v_list->lv_first != NULL)
+    {
+       // Use the type of the first member, it is the most specific.
+       member_type = typval2type(&tv->vval.v_list->lv_first->li_tv, type_gap);
+       return get_list_type(member_type, type_gap);
+    }
+
+    if (tv->v_type == VAR_DICT
+           && tv->vval.v_dict != NULL
+           && tv->vval.v_dict->dv_hashtab.ht_used > 0)
+    {
+       dict_iterator_T iter;
+       typval_T        *value;
+
+       // Use the type of the first value, it is the most specific.
+       dict_iterate_start(tv, &iter);
+       dict_iterate_next(&iter, &value);
+       member_type = typval2type(value, type_gap);
+       return get_dict_type(member_type, type_gap);
+    }
+
+    if (tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
+    {
+       char_u  *name = NULL;
+       ufunc_T *ufunc = NULL;
+
+       if (tv->v_type == VAR_PARTIAL)
+       {
+           if (tv->vval.v_partial->pt_func != NULL)
+               ufunc = tv->vval.v_partial->pt_func;
+           else
+               name = tv->vval.v_partial->pt_name;
+       }
+       else
+           name = tv->vval.v_string;
+       if (name != NULL)
+           // TODO: how about a builtin function?
+           ufunc = find_func(name, FALSE, NULL);
+       if (ufunc != NULL && ufunc->uf_func_type != NULL)
+           return ufunc->uf_func_type;
+    }
+
+    actual = alloc_type(type_gap);
+    if (actual == NULL)
+       return NULL;
+    actual->tt_type = tv->v_type;
+    actual->tt_member = &t_any;
+
+    return actual;
+}
+
+/*
+ * Get a type_T for a typval_T, used for v: variables.
+ * "type_list" is used to temporarily create types in.
+ */
+    type_T *
+typval2type_vimvar(typval_T *tv, garray_T *type_gap)
+{
     if (tv->v_type == VAR_LIST)  // e.g. for v:oldfiles
        return &t_list_string;
     if (tv->v_type == VAR_DICT)  // e.g. for v:completed_item
        return &t_dict_any;
-    return &t_any;  // not used
+    return typval2type(tv, type_gap);
+}
+
+
+/*
+ * Return FAIL if "expected" and "actual" don't match.
+ */
+    int
+check_typval_type(type_T *expected, typval_T *actual_tv)
+{
+    garray_T   type_list;
+    type_T     *actual_type;
+    int                res = FAIL;
+
+    ga_init2(&type_list, sizeof(type_T *), 10);
+    actual_type = typval2type(actual_tv, &type_list);
+    if (actual_type != NULL)
+       res = check_type(expected, actual_type, TRUE);
+    clear_type_list(&type_list);
+    return res;
 }
 
     static void
@@ -561,71 +645,6 @@ check_type(type_T *expected, type_T *actual, int give_msg)
     return ret;
 }
 
-/*
- * Return FAIl if "expected" and "actual" don't match.
- * TODO: better type comparison
- */
-    int
-check_argtype(type_T *expected, typval_T *actual_tv)
-{
-    type_T  actual;
-    type_T  member;
-
-    // TODO: should should be done with more levels
-    CLEAR_FIELD(actual);
-    actual.tt_type = actual_tv->v_type;
-    if (actual_tv->v_type == VAR_LIST
-           && actual_tv->vval.v_list != NULL
-           && actual_tv->vval.v_list->lv_first != NULL)
-    {
-       // Use the type of the first member, it is the most specific.
-       CLEAR_FIELD(member);
-       member.tt_type = actual_tv->vval.v_list->lv_first->li_tv.v_type;
-       member.tt_member = &t_any;
-       actual.tt_member = &member;
-    }
-    else if (actual_tv->v_type == VAR_DICT
-           && actual_tv->vval.v_dict != NULL
-           && actual_tv->vval.v_dict->dv_hashtab.ht_used > 0)
-    {
-       dict_iterator_T iter;
-       typval_T        *value;
-
-       // Use the type of the first value, it is the most specific.
-       dict_iterate_start(actual_tv, &iter);
-       dict_iterate_next(&iter, &value);
-       CLEAR_FIELD(member);
-       member.tt_type = value->v_type;
-       member.tt_member = &t_any;
-       actual.tt_member = &member;
-    }
-    else if (actual_tv->v_type == VAR_FUNC || actual_tv->v_type == VAR_PARTIAL)
-    {
-       char_u  *name = NULL;
-       ufunc_T *ufunc = NULL;
-
-       if (actual_tv->v_type == VAR_PARTIAL)
-       {
-           if (actual_tv->vval.v_partial->pt_func != NULL)
-               ufunc = actual_tv->vval.v_partial->pt_func;
-           else
-               name = actual_tv->vval.v_partial->pt_name;
-       }
-       else
-           name = actual_tv->vval.v_string;
-       if (name != NULL)
-           // TODO: how about a builtin function?
-           ufunc = find_func(name, FALSE, NULL);
-       if (ufunc != NULL && ufunc->uf_func_type != NULL)
-           actual = *ufunc->uf_func_type;
-       else
-           actual.tt_member = &t_any;
-    }
-    else
-       actual.tt_member = &t_any;
-    return check_type(expected, &actual, TRUE);
-}
-
 
 /////////////////////////////////////////////////////////////////////
 // Following generate_ functions expect the caller to call ga_grow().
@@ -1314,7 +1333,7 @@ generate_LOADV(
            semsg(_(e_var_notfound), name);
        return FAIL;
     }
-    type = typval2type(get_vim_var_tv(vidx));
+    type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list);
 
     return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
 }
@@ -5235,7 +5254,7 @@ compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
                    goto theend;
                dest = dest_vimvar;
                vtv = get_vim_var_tv(vimvaridx);
-               type = typval2type(vtv);
+               type = typval2type_vimvar(vtv, cctx->ctx_type_list);
                if (is_decl)
                {
                    vim9_declare_error(name);

diff --git a/src/vim9execute.c b/src/vim9execute.c
index c75e095549552919960493ae04c2dab2a4752d0a..ab8142d23cb44913bd4ac453a96a0e486019dbcc 100644 (file)
--- a/src/vim9execute.c
+++ b/src/vim9execute.c
@@ -737,7 +737,8 @@ call_def_function(
     for (idx = 0; idx < argc; ++idx)
     {
        if (ufunc->uf_arg_types != NULL && idx < ufunc->uf_args.ga_len
-               && check_argtype(ufunc->uf_arg_types[idx], &argv[idx]) == FAIL)
+               && check_typval_type(ufunc->uf_arg_types[idx], &argv[idx])
+                                                                      == FAIL)
            goto failed_early;
        copy_tv(&argv[idx], STACK_TV_BOT(0));
        ++ectx.ec_stack.ga_len;

diff --git a/src/vim9script.c b/src/vim9script.c
index 3c57d341bcdb15efb6765c6df7b549ed3a8131b4..24953cd60a1ebebd0fc990a2989df65fd5249f0e 100644 (file)
--- a/src/vim9script.c
+++ b/src/vim9script.c
@@ -557,7 +557,7 @@ check_script_var_type(typval_T *dest, typval_T *value, char_u *name)
                semsg(_(e_readonlyvar), name);
                return FAIL;
            }
-           return check_type(sv->sv_type, typval2type(value), TRUE);
+           return check_typval_type(sv->sv_type, value);
        }
     }
     iemsg("check_script_var_type(): not found");