patch 8.2.1068: Vim9: no line break allowed inside a dict

Problem:    Vim9: no line break allowed inside a dict.
Solution:   Handle line break inside a dict in Vim9 script.

diff --git a/src/dict.c b/src/dict.c
index caa398deba9598df5c516a51b10961eb4b1c253f..748a9917ebc98d70f03f86bbb986466558169a14 100644 (file)
--- a/src/dict.c
+++ b/src/dict.c
@@ -792,10 +792,10 @@ get_literal_key(char_u **arg, typval_T *tv)
  * Return OK or FAIL.  Returns NOTDONE for {expr}.
  */
     int
-eval_dict(char_u **arg, typval_T *rettv, int flags, int literal)
+eval_dict(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int literal)
 {
-    int                evaluate = flags & EVAL_EVALUATE;
-    evalarg_T  evalarg;
+    int                evaluate = evalarg == NULL ? FALSE
+                                        : evalarg->eval_flags & EVAL_EVALUATE;
     dict_T     *d = NULL;
     typval_T   tvkey;
     typval_T   tv;
@@ -804,9 +804,8 @@ eval_dict(char_u **arg, typval_T *rettv, int flags, int literal)
     char_u     *start = skipwhite(*arg + 1);
     char_u     buf[NUMBUFLEN];
     int                vim9script = current_sctx.sc_version == SCRIPT_VERSION_VIM9;
-
-    CLEAR_FIELD(evalarg);
-    evalarg.eval_flags = flags;
+    int                had_comma;
+    int                getnext;
 
     /*
      * First check if it's not a curly-braces thing: {expr}.
@@ -833,11 +832,14 @@ eval_dict(char_u **arg, typval_T *rettv, int flags, int literal)
     tv.v_type = VAR_UNKNOWN;
 
     *arg = skipwhite(*arg + 1);
+    eval_next_non_blank(*arg, evalarg, &getnext);
+    if (getnext)
+       *arg = eval_next_line(evalarg);
     while (**arg != '}' && **arg != NUL)
     {
        if ((literal
                ? get_literal_key(arg, &tvkey)
-               : eval1(arg, &tvkey, &evalarg)) == FAIL)        // recursive!
+               : eval1(arg, &tvkey, evalarg)) == FAIL) // recursive!
            goto failret;
 
        if (**arg != ':')
@@ -857,9 +859,17 @@ eval_dict(char_u **arg, typval_T *rettv, int flags, int literal)
                goto failret;
            }
        }
+       if (vim9script && (*arg)[1] != NUL && !VIM_ISWHITE((*arg)[1]))
+       {
+           semsg(_(e_white_after), ":");
+           goto failret;
+       }
 
        *arg = skipwhite(*arg + 1);
-       if (eval1(arg, &tv, &evalarg) == FAIL)  // recursive!
+       eval_next_non_blank(*arg, evalarg, &getnext);
+       if (getnext)
+           *arg = eval_next_line(evalarg);
+       if (eval1(arg, &tv, evalarg) == FAIL)   // recursive!
        {
            if (evaluate)
                clear_tv(&tvkey);
@@ -887,15 +897,30 @@ eval_dict(char_u **arg, typval_T *rettv, int flags, int literal)
        }
        clear_tv(&tvkey);
 
+       // the comma must come after the value
+       had_comma = **arg == ',';
+       if (had_comma)
+       {
+           if (vim9script && (*arg)[1] != NUL && !VIM_ISWHITE((*arg)[1]))
+           {
+               semsg(_(e_white_after), ",");
+               goto failret;
+           }
+           *arg = skipwhite(*arg + 1);
+       }
+
+       // the "}" can be on the next line
+       eval_next_non_blank(*arg, evalarg, &getnext);
+       if (getnext)
+           *arg = eval_next_line(evalarg);
        if (**arg == '}')
            break;
-       if (**arg != ',')
+       if (!had_comma)
        {
            if (evaluate)
                semsg(_(e_missing_dict_comma), *arg);
            goto failret;
        }
-       *arg = skipwhite(*arg + 1);
     }
 
     if (**arg != '}')

diff --git a/src/eval.c b/src/eval.c
index 4bbf65b036f6d0f2804d32a4aae1da0d405a88cd..0c8ab49c7fa639beaaad36bb9e75495edc7ef793 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -2787,7 +2787,7 @@ eval7(
     case '#':  if ((*arg)[1] == '{')
                {
                    ++*arg;
-                   ret = eval_dict(arg, rettv, flags, TRUE);
+                   ret = eval_dict(arg, rettv, evalarg, TRUE);
                }
                else
                    ret = NOTDONE;
@@ -2799,7 +2799,7 @@ eval7(
      */
     case '{':  ret = get_lambda_tv(arg, rettv, evaluate);
                if (ret == NOTDONE)
-                   ret = eval_dict(arg, rettv, flags, FALSE);
+                   ret = eval_dict(arg, rettv, evalarg, FALSE);
                break;
 
     /*

diff --git a/src/proto/dict.pro b/src/proto/dict.pro
index 45bcfbf3a9f7985812a1ef79fdcbadd811b3ead1..093139f4299c119af8849701f8bdfc2e60e82f2c 100644 (file)
--- a/src/proto/dict.pro
+++ b/src/proto/dict.pro
@@ -32,7 +32,7 @@ varnumber_T dict_get_number(dict_T *d, char_u *key);
 varnumber_T dict_get_number_def(dict_T *d, char_u *key, int def);
 varnumber_T dict_get_number_check(dict_T *d, char_u *key);
 char_u *dict2string(typval_T *tv, int copyID, int restore_copyID);
-int eval_dict(char_u **arg, typval_T *rettv, int evaluate, int literal);
+int eval_dict(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int literal);
 void dict_extend(dict_T *d1, dict_T *d2, char_u *action);
 dictitem_T *dict_lookup(hashitem_T *hi);
 int dict_equal(dict_T *d1, dict_T *d2, int ic, int recursive);

diff --git a/src/testdir/test_vim9_expr.vim b/src/testdir/test_vim9_expr.vim
index 0976d9cdb14149449a65061bc57efa72b9c98279..30cf1b995be8fb50aa8ea7ca79345ed18aec9c0b 100644 (file)
--- a/src/testdir/test_vim9_expr.vim
+++ b/src/testdir/test_vim9_expr.vim
@@ -1002,6 +1002,12 @@ def Test_expr7_list_vim9script()
       assert_equal([11, 22], l)
   END
   CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      let l = [11,22]
+  END
+  CheckScriptFailure(lines, 'E1069:')
 enddef
 
 def Test_expr7_lambda()
@@ -1034,6 +1040,40 @@ def Test_expr7_dict()
   call CheckDefExecFailure(["let x = g:dict_empty.member"], 'E716:')
 enddef
 
+def Test_expr7_dict_vim9script()
+  let lines =<< trim END
+      vim9script
+      let d = {
+               'one':
+                  1,
+               'two': 2,
+                  }
+      assert_equal({'one': 1, 'two': 2}, d)
+  END
+  CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      let d = #{one: 1,
+               two: 2,
+              }
+      assert_equal({'one': 1, 'two': 2}, d)
+  END
+  CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      let d = #{one:1, two: 2}
+  END
+  CheckScriptFailure(lines, 'E1069:')
+
+  lines =<< trim END
+      vim9script
+      let d = #{one: 1,two: 2}
+  END
+  CheckScriptFailure(lines, 'E1069:')
+enddef
+
 def Test_expr_member()
   assert_equal(1, g:dict_one.one)
   let d: dict<number> = g:dict_one

diff --git a/src/version.c b/src/version.c
index 0ab2b6ab4336796c757cc6cca4f75318b33c55b8..f73afd8a1a6daa39c41fe38de3a22c14d7e55937 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 */
+/**/
+    1068,
 /**/
     1067,
 /**/

diff --git a/src/vim9compile.c b/src/vim9compile.c
index f133a94b734ddda19e6eba1acd1c34ea3855feaf..5d03e0f92c83d56622d393a382a3894b01b2ebf9 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -2996,7 +2996,7 @@ to_name_const_end(char_u *arg)
     {
        // Can be "#{a: 1}->Func()".
        ++p;
-       if (eval_dict(&p, &rettv, 0, TRUE) == FAIL)
+       if (eval_dict(&p, &rettv, NULL, TRUE) == FAIL)
            p = arg;
     }
     else if (p == arg && *arg == '{')
@@ -3006,7 +3006,7 @@ to_name_const_end(char_u *arg)
        // Can be "{x -> ret}()".
        // Can be "{'a': 1}->Func()".
        if (ret == NOTDONE)
-           ret = eval_dict(&p, &rettv, 0, FALSE);
+           ret = eval_dict(&p, &rettv, NULL, FALSE);
        if (ret != OK)
            p = arg;
     }