patch 8.2.0493: Vim9: some error messages not tested

Problem:    Vim9: some error messages not tested.
Solution:   Add more tests.  Fix uncovered bugs.

diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 74c3d1cfa0cda9754659c9f5073285d425e9e0a1..3c0a1ae7f9f98869485a94f4ba77a5845985db17 100644 (file)
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -2861,6 +2861,7 @@ test_ignore_error({expr}) none    ignore a specific error
 test_null_blob()               Blob    null value for testing
 test_null_channel()            Channel null value for testing
 test_null_dict()               Dict    null value for testing
+test_null_function()           Funcref null value for testing
 test_null_job()                        Job     null value for testing
 test_null_list()               List    null value for testing
 test_null_partial()            Funcref null value for testing

diff --git a/runtime/doc/testing.txt b/runtime/doc/testing.txt
index 82dc77ecbf6a49838d354c0bf8acf230b8a31606..458aa7cbb01a5649ded0d357922bc058d4348469 100644 (file)
--- a/runtime/doc/testing.txt
+++ b/runtime/doc/testing.txt
@@ -106,6 +106,10 @@ test_null_dict()                                   *test_null_dict()*
                Return a |Dict| that is null. Only useful for testing.
 
 
+test_null_function()                                   *test_null_function()*
+               Return a |FuncRef| that is null. Only useful for testing.
+
+
 test_null_job()                                                *test_null_job()*
                Return a |Job| that is null. Only useful for testing.
                {only available when compiled with the +job feature}

diff --git a/src/eval.c b/src/eval.c
index 975afe577cb842f35cf31902ff57cdef67f00e34..78673759c16a3d5f5c68c54a2fb5cf25dee90aaa 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -3849,8 +3849,12 @@ tv_equal(
            return tv1->vval.v_channel == tv2->vval.v_channel;
 #endif
 
-       case VAR_FUNC:
        case VAR_PARTIAL:
+           return tv1->vval.v_partial == tv2->vval.v_partial;
+
+       case VAR_FUNC:
+           return tv1->vval.v_string == tv2->vval.v_string;
+
        case VAR_UNKNOWN:
        case VAR_VOID:
            break;

diff --git a/src/evalfunc.c b/src/evalfunc.c
index 5f290aa69e46b6c1fad2a3659ffdac1bf5dd4f97..6832bf171446bfadf0b5e344d98b99d5fff57d90 100644 (file)
--- a/src/evalfunc.c
+++ b/src/evalfunc.c
@@ -290,7 +290,8 @@ ret_string(int argcount UNUSED, type_T **argtypes UNUSED)
 {
     return &t_string;
 }
-    static type_T * ret_list_any(int argcount UNUSED, type_T **argtypes UNUSED)
+    static type_T *
+ret_list_any(int argcount UNUSED, type_T **argtypes UNUSED)
 {
     return &t_list_any;
 }
@@ -330,9 +331,14 @@ ret_blob(int argcount UNUSED, type_T **argtypes UNUSED)
     return &t_blob;
 }
     static type_T *
-ret_partial_void(int argcount UNUSED, type_T **argtypes UNUSED)
+ret_func_any(int argcount UNUSED, type_T **argtypes UNUSED)
 {
-    return &t_partial_void;
+    return &t_func_any;
+}
+    static type_T *
+ret_partial_any(int argcount UNUSED, type_T **argtypes UNUSED)
+{
+    return &t_partial_any;
 }
     static type_T *
 ret_channel(int argcount UNUSED, type_T **argtypes UNUSED)
@@ -558,7 +564,7 @@ static funcentry_T global_functions[] =
     {"foldtext",       0, 0, 0,          ret_string,   f_foldtext},
     {"foldtextresult", 1, 1, FEARG_1,    ret_string,   f_foldtextresult},
     {"foreground",     0, 0, 0,          ret_void,     f_foreground},
-    {"funcref",                1, 3, FEARG_1,    ret_partial_void, f_funcref},
+    {"funcref",                1, 3, FEARG_1,    ret_partial_any, f_funcref},
     {"function",       1, 3, FEARG_1,    ret_f_function, f_function},
     {"garbagecollect", 0, 1, 0,          ret_void,     f_garbagecollect},
     {"get",            2, 3, FEARG_1,    ret_any,      f_get},
@@ -952,9 +958,10 @@ static funcentry_T global_functions[] =
     {"test_null_blob", 0, 0, 0,          ret_blob,     f_test_null_blob},
     {"test_null_channel", 0, 0, 0,       ret_channel,  JOB_FUNC(f_test_null_channel)},
     {"test_null_dict", 0, 0, 0,          ret_dict_any, f_test_null_dict},
+    {"test_null_function", 0, 0, 0,      ret_func_any, f_test_null_function},
     {"test_null_job",  0, 0, 0,          ret_job,      JOB_FUNC(f_test_null_job)},
     {"test_null_list", 0, 0, 0,          ret_list_any, f_test_null_list},
-    {"test_null_partial", 0, 0, 0,       ret_partial_void, f_test_null_partial},
+    {"test_null_partial", 0, 0, 0,       ret_partial_any, f_test_null_partial},
     {"test_null_string", 0, 0, 0,        ret_string,   f_test_null_string},
     {"test_option_not_set", 1, 1, FEARG_1,ret_void,     f_test_option_not_set},
     {"test_override",  2, 2, FEARG_2,    ret_void,     f_test_override},

diff --git a/src/proto/testing.pro b/src/proto/testing.pro
index 7542ccb4461695278967beb69db274a2f7f5ed13..b812c2a270ef21f0351a704fba92e3bd17623883 100644 (file)
--- a/src/proto/testing.pro
+++ b/src/proto/testing.pro
@@ -26,6 +26,7 @@ void f_test_null_channel(typval_T *argvars, typval_T *rettv);
 void f_test_null_dict(typval_T *argvars, typval_T *rettv);
 void f_test_null_job(typval_T *argvars, typval_T *rettv);
 void f_test_null_list(typval_T *argvars, typval_T *rettv);
+void f_test_null_function(typval_T *argvars, typval_T *rettv);
 void f_test_null_partial(typval_T *argvars, typval_T *rettv);
 void f_test_null_string(typval_T *argvars, typval_T *rettv);
 void f_test_unknown(typval_T *argvars, typval_T *rettv);

diff --git a/src/testdir/test_vim9_script.vim b/src/testdir/test_vim9_script.vim
index 0c0bf83a860743ce812cacf38ef644e838d225aa..1449017ca9fabcb3cb8115b566090470dccb8f25 100644 (file)
--- a/src/testdir/test_vim9_script.vim
+++ b/src/testdir/test_vim9_script.vim
@@ -117,6 +117,48 @@ def Test_assignment()
   assert_equal('aregadd', @a)
   call CheckDefFailure(['@a += "more"'], 'E1013:')
   call CheckDefFailure(['@a += 123'], 'E1013:')
+
+  v:errmsg = 'none'
+  v:errmsg ..= 'again'
+  assert_equal('noneagain', v:errmsg)
+  call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
+  call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
+
+  " Test default values.
+  let thebool: bool
+  assert_equal(v:false, thebool)
+
+  let thenumber: number
+  assert_equal(0, thenumber)
+
+  if has('float')
+    let thefloat: float
+    assert_equal(0.0, thefloat)
+  endif
+
+  let thestring: string
+  assert_equal('', thestring)
+
+  let theblob: blob
+  assert_equal(0z, theblob)
+
+  let thefunc: func
+  assert_equal(test_null_function(), thefunc)
+
+  let thepartial: partial
+  assert_equal(test_null_partial(), thepartial)
+
+  let thelist: list<any>
+  assert_equal([], thelist)
+
+  let thedict: dict<any>
+  assert_equal({}, thedict)
+
+  let thejob: job
+  assert_equal(test_null_job(), thejob)
+
+  let thechannel: channel
+  assert_equal(test_null_channel(), thechannel)
 enddef
 
 func Test_assignment_failure()
@@ -129,6 +171,7 @@ func Test_assignment_failure()
 
   call CheckDefFailure(['let [a; b; c] = g:list'], 'E452:')
 
+  call CheckDefFailure(['let somevar'], "E1022:")
   call CheckDefFailure(['let &option'], 'E1052:')
   call CheckDefFailure(['&g:option = 5'], 'E113:')
 

diff --git a/src/testing.c b/src/testing.c
index 8a64ce85e7c6e5f0d4faa260005b66486851f112..81e17622dd6e2187e640facd8112d40e7f70c301 100644 (file)
--- a/src/testing.c
+++ b/src/testing.c
@@ -882,6 +882,13 @@ f_test_null_list(typval_T *argvars UNUSED, typval_T *rettv)
     rettv_list_set(rettv, NULL);
 }
 
+    void
+f_test_null_function(typval_T *argvars UNUSED, typval_T *rettv)
+{
+    rettv->v_type = VAR_FUNC;
+    rettv->vval.v_string = NULL;
+}
+
     void
 f_test_null_partial(typval_T *argvars UNUSED, typval_T *rettv)
 {

diff --git a/src/version.c b/src/version.c
index 5fc599c467bda51fde20b944ce7f712841438507..3686a1d51b1267fb43d2b27f8a5f7b57bc1f70af 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -738,6 +738,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    493,
 /**/
     492,
 /**/

diff --git a/src/vim9compile.c b/src/vim9compile.c
index 2726e387f756a3098338e60e6caab891ff372815..ce1ca76c24b51fa6296565a3e3a9de2b77d91ce0 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -766,7 +766,7 @@ generate_PUSHFUNC(cctx_T *cctx, char_u *name)
 
 /*
  * Generate an ISN_PUSHPARTIAL instruction with partial "part".
- * Consumes "name".
+ * Consumes "part".
  */
     static int
 generate_PUSHPARTIAL(cctx_T *cctx, partial_T *part)
@@ -3808,9 +3808,6 @@ compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
            case VAR_BOOL:
                generate_PUSHBOOL(cctx, VVAL_FALSE);
                break;
-           case VAR_SPECIAL:
-               generate_PUSHSPEC(cctx, VVAL_NONE);
-               break;
            case VAR_FLOAT:
 #ifdef FEAT_FLOAT
                generate_PUSHF(cctx, 0.0);
@@ -3843,6 +3840,7 @@ compile_assignment(char_u *arg, exarg_T *eap, cmdidx_T cmdidx, cctx_T *cctx)
            case VAR_NUMBER:
            case VAR_UNKNOWN:
            case VAR_VOID:
+           case VAR_SPECIAL:  // cannot happen
                generate_PUSHNR(cctx, 0);
                break;
        }

diff --git a/src/vim9execute.c b/src/vim9execute.c
index 89e4f054b0905d4798c1b871d0557f1273a5f5e1..54f95bf66e8451b115edbdabf0c188984aab2952 100644 (file)
--- a/src/vim9execute.c
+++ b/src/vim9execute.c
@@ -920,7 +920,9 @@ call_def_function(
                        break;
                    default:
                        tv->v_type = VAR_STRING;
-                       tv->vval.v_string = vim_strsave(iptr->isn_arg.string);
+                       tv->vval.v_string = vim_strsave(
+                               iptr->isn_arg.string == NULL
+                                       ? (char_u *)"" : iptr->isn_arg.string);
                }
                break;