patch 8.2.1551: Vim9: error for argument type does not mention the number

Problem:    Vim9: error for argument type does not mention the number.
Solution:   Pass the argument number to where the error is given.

diff --git a/src/eval.c b/src/eval.c
index d12708e226893278a111ef9be7c5a78f5b2f2be8..be3f4622cba4084c24619792518e61538ee1e10b 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -1291,7 +1291,7 @@ set_var_lval(
        else
        {
            if (lp->ll_type != NULL
-                             && check_typval_type(lp->ll_type, rettv) == FAIL)
+                          && check_typval_type(lp->ll_type, rettv, 0) == FAIL)
                return;
            set_var_const(lp->ll_name, lp->ll_type, rettv, copy, flags);
        }

diff --git a/src/proto/vim9type.pro b/src/proto/vim9type.pro
index 5ad87e8e0eb9e361e4725debbd1a66552ac09f21..1ac372732fee4cc9d18d722535c88cfe5a9e1596 100644 (file)
--- a/src/proto/vim9type.pro
+++ b/src/proto/vim9type.pro
@@ -7,10 +7,10 @@ type_T *get_func_type(type_T *ret_type, int argcount, garray_T *type_gap);
 int func_type_add_arg_types(type_T *functype, int argcount, garray_T *type_gap);
 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_typval_type(type_T *expected, typval_T *actual_tv, int argidx);
 void type_mismatch(type_T *expected, type_T *actual);
 void arg_type_mismatch(type_T *expected, type_T *actual, int argidx);
-int check_type(type_T *expected, type_T *actual, int give_msg);
+int check_type(type_T *expected, type_T *actual, int give_msg, int argidx);
 char_u *skip_type(char_u *start, int optional);
 type_T *parse_type(char_u **arg, garray_T *type_gap);
 void common_type(type_T *type1, type_T *type2, type_T **dest, garray_T *type_gap);

diff --git a/src/testdir/test_vim9_func.vim b/src/testdir/test_vim9_func.vim
index 0d27f2ddbeba5f7454743293fb4bc0798b114abe..282d8dcec249ab53ea1a3040967c1f1094d740c7 100644 (file)
--- a/src/testdir/test_vim9_func.vim
+++ b/src/testdir/test_vim9_func.vim
@@ -231,7 +231,7 @@ def Test_call_wrong_args()
     enddef
     Func([])
   END
-  call CheckScriptFailure(lines, 'E1012: type mismatch, expected string but got list<unknown>', 5)
+  call CheckScriptFailure(lines, 'E1013: argument 1: type mismatch, expected string but got list<unknown>', 5)
 enddef
 
 " Default arg and varargs
@@ -278,7 +278,7 @@ def Test_call_def_varargs()
       enddef
       Func(1, 2, 3)
   END
-  CheckScriptFailure(lines, 'E1012:')
+  CheckScriptFailure(lines, 'E1013: argument 1: type mismatch')
 
   lines =<< trim END
       vim9script
@@ -287,7 +287,7 @@ def Test_call_def_varargs()
       enddef
       Func('a', 9)
   END
-  CheckScriptFailure(lines, 'E1012:')
+  CheckScriptFailure(lines, 'E1013: argument 2: type mismatch')
 
   lines =<< trim END
       vim9script
@@ -296,7 +296,7 @@ def Test_call_def_varargs()
       enddef
       Func(1, 'a')
   END
-  CheckScriptFailure(lines, 'E1012:')
+  CheckScriptFailure(lines, 'E1013: argument 1: type mismatch')
 enddef
 
 def Test_call_call()
@@ -691,7 +691,7 @@ def Test_vim9script_call_fail_type()
     enddef
     MyFunc(1234)
   END
-  CheckScriptFailure(lines, 'E1012: type mismatch, expected string but got number')
+  CheckScriptFailure(lines, 'E1013: argument 1: type mismatch, expected string but got number')
 enddef
 
 def Test_vim9script_call_fail_const()

diff --git a/src/version.c b/src/version.c
index 8e112994af91ce782d29a944a5e4157e98e9cc58..901f54086180eb85a7c3b9b7ece9dff8595aed09 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 */
+/**/
+    1551,
 /**/
     1550,
 /**/

diff --git a/src/vim9compile.c b/src/vim9compile.c
index bec6988e546c0b94852f35454dd27228701b60fe..0c9f56f5a01cd33f546855f5db9b3682128017fb 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -729,7 +729,7 @@ need_type(
        cctx_T  *cctx,
        int     silent)
 {
-    if (check_type(expected, actual, FALSE) == OK)
+    if (check_type(expected, actual, FALSE, 0) == OK)
        return OK;
     if (actual->tt_type != VAR_ANY
            && actual->tt_type != VAR_UNKNOWN
@@ -3581,7 +3581,7 @@ compile_expr7t(char_u **arg, cctx_T *cctx, ppconst_T *ppconst)
 
        generate_ppconst(cctx, ppconst);
        actual = ((type_T **)stack->ga_data)[stack->ga_len - 1];
-       if (check_type(want_type, actual, FALSE) == FAIL)
+       if (check_type(want_type, actual, FALSE, 0) == FAIL)
        {
            if (need_type(actual, want_type, -1, cctx, FALSE) == FAIL)
                return FAIL;
@@ -6500,13 +6500,9 @@ compile_def_function(ufunc_T *ufunc, int set_return_type, cctx_T *outer_cctx)
                did_set_arg_type = TRUE;
                ufunc->uf_arg_types[arg_idx] = val_type;
            }
-           else if (check_type(ufunc->uf_arg_types[arg_idx], val_type, FALSE)
-                                                                      == FAIL)
-           {
-               arg_type_mismatch(ufunc->uf_arg_types[arg_idx], val_type,
-                                                                 arg_idx + 1);
+           else if (check_type(ufunc->uf_arg_types[arg_idx], val_type,
+                                                   TRUE, arg_idx + 1) == FAIL)
                goto erret;
-           }
 
            if (generate_STORE(&cctx, ISN_STORE, i - count - off, NULL) == FAIL)
                goto erret;

diff --git a/src/vim9execute.c b/src/vim9execute.c
index 9bc0d45d34400d3a33682cfb94ba5daab2e060ea..7a2b21d359bb07541f184c4358430224090f71a4 100644 (file)
--- a/src/vim9execute.c
+++ b/src/vim9execute.c
@@ -792,8 +792,8 @@ call_def_function(
     for (idx = 0; idx < argc; ++idx)
     {
        if (ufunc->uf_arg_types != NULL && idx < ufunc->uf_args.ga_len
-               && check_typval_type(ufunc->uf_arg_types[idx], &argv[idx])
-                                                                      == FAIL)
+               && check_typval_type(ufunc->uf_arg_types[idx], &argv[idx],
+                                                             idx + 1) == FAIL)
            goto failed_early;
        copy_tv(&argv[idx], STACK_TV_BOT(0));
        ++ectx.ec_stack.ga_len;
@@ -822,7 +822,8 @@ call_def_function(
 
            for (idx = 0; idx < vararg_count; ++idx)
            {
-               if (check_typval_type(expected, &li->li_tv) == FAIL)
+               if (check_typval_type(expected, &li->li_tv,
+                                                      argc + idx + 1) == FAIL)
                    goto failed_early;
                li = li->li_next;
            }

diff --git a/src/vim9script.c b/src/vim9script.c
index e86150a1ee1692181d0e2ff603d3c8cc6b45237c..ed1d6da4819929e9068e2e2171903f48996eb71e 100644 (file)
--- a/src/vim9script.c
+++ b/src/vim9script.c
@@ -580,7 +580,7 @@ check_script_var_type(typval_T *dest, typval_T *value, char_u *name)
                semsg(_(e_readonlyvar), name);
                return FAIL;
            }
-           return check_typval_type(sv->sv_type, value);
+           return check_typval_type(sv->sv_type, value, 0);
        }
     }
     iemsg("check_script_var_type(): not found");

diff --git a/src/vim9type.c b/src/vim9type.c
index 07a087ba4e4e43b709bc16ec922bd42d0d379cfe..29466d0064b351d9105381cb1b5b5743519378c0 100644 (file)
--- a/src/vim9type.c
+++ b/src/vim9type.c
@@ -304,7 +304,7 @@ typval2type_vimvar(typval_T *tv, garray_T *type_gap)
  * Return FAIL if "expected" and "actual" don't match.
  */
     int
-check_typval_type(type_T *expected, typval_T *actual_tv)
+check_typval_type(type_T *expected, typval_T *actual_tv, int argidx)
 {
     garray_T   type_list;
     type_T     *actual_type;
@@ -313,7 +313,7 @@ check_typval_type(type_T *expected, typval_T *actual_tv)
     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);
+       res = check_type(expected, actual_type, TRUE, argidx);
     clear_type_list(&type_list);
     return res;
 }
@@ -321,22 +321,22 @@ check_typval_type(type_T *expected, typval_T *actual_tv)
     void
 type_mismatch(type_T *expected, type_T *actual)
 {
-    char *tofree1, *tofree2;
-
-    semsg(_(e_type_mismatch_expected_str_but_got_str),
-                  type_name(expected, &tofree1), type_name(actual, &tofree2));
-    vim_free(tofree1);
-    vim_free(tofree2);
+    arg_type_mismatch(expected, actual, 0);
 }
 
     void
 arg_type_mismatch(type_T *expected, type_T *actual, int argidx)
 {
     char *tofree1, *tofree2;
-
-    semsg(_(e_argument_nr_type_mismatch_expected_str_but_got_str),
-           argidx,
-           type_name(expected, &tofree1), type_name(actual, &tofree2));
+    char *typename1 = type_name(expected, &tofree1);
+    char *typename2 = type_name(actual, &tofree2);
+
+    if (argidx > 0)
+       semsg(_(e_argument_nr_type_mismatch_expected_str_but_got_str),
+                                                argidx, typename1, typename2);
+    else
+       semsg(_(e_type_mismatch_expected_str_but_got_str),
+                                                        typename1, typename2);
     vim_free(tofree1);
     vim_free(tofree2);
 }
@@ -344,9 +344,10 @@ arg_type_mismatch(type_T *expected, type_T *actual, int argidx)
 /*
  * Check if the expected and actual types match.
  * Does not allow for assigning "any" to a specific type.
+ * When "argidx" > 0 it is included in the error message.
  */
     int
-check_type(type_T *expected, type_T *actual, int give_msg)
+check_type(type_T *expected, type_T *actual, int give_msg, int argidx)
 {
     int ret = OK;
 
@@ -359,19 +360,21 @@ check_type(type_T *expected, type_T *actual, int give_msg)
        if (expected->tt_type != actual->tt_type)
        {
            if (give_msg)
-               type_mismatch(expected, actual);
+               arg_type_mismatch(expected, actual, argidx);
            return FAIL;
        }
        if (expected->tt_type == VAR_DICT || expected->tt_type == VAR_LIST)
        {
            // "unknown" is used for an empty list or dict
            if (actual->tt_member != &t_unknown)
-               ret = check_type(expected->tt_member, actual->tt_member, FALSE);
+               ret = check_type(expected->tt_member, actual->tt_member,
+                                                                    FALSE, 0);
        }
        else if (expected->tt_type == VAR_FUNC)
        {
            if (expected->tt_member != &t_unknown)
-               ret = check_type(expected->tt_member, actual->tt_member, FALSE);
+               ret = check_type(expected->tt_member, actual->tt_member,
+                                                                    FALSE, 0);
            if (ret == OK && expected->tt_argcount != -1
                    && (actual->tt_argcount < expected->tt_min_argcount
                        || actual->tt_argcount > expected->tt_argcount))
@@ -383,7 +386,7 @@ check_type(type_T *expected, type_T *actual, int give_msg)
                for (i = 0; i < expected->tt_argcount; ++i)
                    // Allow for using "any" argument type, lambda's have them.
                    if (actual->tt_args[i] != &t_any && check_type(
-                              expected->tt_args[i], actual->tt_args[i], FALSE)
+                           expected->tt_args[i], actual->tt_args[i], FALSE, 0)
                                                                       == FAIL)
                    {
                        ret = FAIL;
@@ -392,7 +395,7 @@ check_type(type_T *expected, type_T *actual, int give_msg)
            }
        }
        if (ret == FAIL && give_msg)
-           type_mismatch(expected, actual);
+           arg_type_mismatch(expected, actual, argidx);
     }
     return ret;
 }