patch 9.1.0335: String interpolation fails for List type

Problem:  String interpolation fails for List type
Solution: use implicit string(list) for string interpolation and :put =
          (Yegappan Lakshmanan)

related: #14529
closes: #14556

Signed-off-by: Yegappan Lakshmanan <[email protected]>
Signed-off-by: Christian Brabandt <[email protected]>

Author: yegappan

src/eval.c

@@ -575,17 +575,16 @@ skip_expr_concatenate(
 
 /*
  * Convert "tv" to a string.
- * When "convert" is TRUE convert a List into a sequence of lines and a Dict
- * into a textual representation of the Dict.
+ * When "join_list" is TRUE convert a List into a sequence of lines.
  * Returns an allocated string (NULL when out of memory).
  */
     char_u *
-typval2string(typval_T *tv, int convert)
+typval2string(typval_T *tv, int join_list)
 {
     garray_T	ga;
     char_u	*retval;
 
-    if (convert && tv->v_type == VAR_LIST)
+    if (join_list && tv->v_type == VAR_LIST)
     {
 	ga_init2(&ga, sizeof(char), 80);
 	if (tv->vval.v_list != NULL)
@@ -597,8 +596,16 @@ typval2string(typval_T *tv, int convert)
 	ga_append(&ga, NUL);
 	retval = (char_u *)ga.ga_data;
     }
-    else if (convert && tv->v_type == VAR_DICT)
-	retval = dict2string(tv, get_copyID(), FALSE);
+    else if (tv->v_type == VAR_LIST || tv->v_type == VAR_DICT)
+    {
+	char_u	*tofree;
+	char_u	numbuf[NUMBUFLEN];
+
+	retval = tv2string(tv, &tofree, numbuf, 0);
+	// Make a copy if we have a value but it's not in allocated memory.
+	if (retval != NULL && tofree == NULL)
+	    retval = vim_strsave(retval);
+    }
     else
 	retval = vim_strsave(tv_get_string(tv));
     return retval;
@@ -607,13 +614,13 @@ typval2string(typval_T *tv, int convert)
 /*
  * Top level evaluation function, returning a string.  Does not handle line
  * breaks.
- * When "convert" is TRUE convert a List into a sequence of lines.
+ * When "join_list" is TRUE convert a List into a sequence of lines.
  * Return pointer to allocated memory, or NULL for failure.
  */
     char_u *
 eval_to_string_eap(
     char_u	*arg,
-    int		convert,
+    int		join_list,
     exarg_T	*eap,
     int		use_simple_function)
 {
@@ -631,7 +638,7 @@ eval_to_string_eap(
 	retval = NULL;
     else
     {
-	retval = typval2string(&tv, convert);
+	retval = typval2string(&tv, join_list);
 	clear_tv(&tv);
     }
     clear_evalarg(&evalarg, NULL);
@@ -642,10 +649,10 @@ eval_to_string_eap(
     char_u *
 eval_to_string(
     char_u	*arg,
-    int		convert,
+    int		join_list,
     int		use_simple_function)
 {
-    return eval_to_string_eap(arg, convert, NULL, use_simple_function);
+    return eval_to_string_eap(arg, join_list, NULL, use_simple_function);
 }
 
 /*

src/evalvars.c

@@ -662,7 +662,7 @@ eval_one_expr_in_str(char_u *p, garray_T *gap, int evaluate)
     if (evaluate)
     {
 	*block_end = NUL;
-	expr_val = eval_to_string(block_start, TRUE, FALSE);
+	expr_val = eval_to_string(block_start, FALSE, FALSE);
 	*block_end = '}';
 	if (expr_val == NULL)
 	    return NULL;

src/proto/eval.pro

@@ -14,9 +14,9 @@ void init_evalarg(evalarg_T *evalarg);
 void clear_evalarg(evalarg_T *evalarg, exarg_T *eap);
 int skip_expr(char_u **pp, evalarg_T *evalarg);
 int skip_expr_concatenate(char_u **arg, char_u **start, char_u **end, evalarg_T *evalarg);
-char_u *typval2string(typval_T *tv, int convert);
-char_u *eval_to_string_eap(char_u *arg, int convert, exarg_T *eap, int use_simple_function);
-char_u *eval_to_string(char_u *arg, int convert, int use_simple_function);
+char_u *typval2string(typval_T *tv, int join_list);
+char_u *eval_to_string_eap(char_u *arg, int join_list, exarg_T *eap, int use_simple_function);
+char_u *eval_to_string(char_u *arg, int join_list, int use_simple_function);
 char_u *eval_to_string_safe(char_u *arg, int use_sandbox, int keep_script_version, int use_simple_function);
 varnumber_T eval_to_number(char_u *expr, int use_simple_function);
 typval_T *eval_expr(char_u *arg, exarg_T *eap);

src/proto/vim9instr.pro

@@ -7,7 +7,7 @@ int generate_CONSTRUCT(cctx_T *cctx, class_T *cl);
 int generate_GET_OBJ_MEMBER(cctx_T *cctx, int idx, type_T *type);
 int generate_GET_ITF_MEMBER(cctx_T *cctx, class_T *itf, int idx, type_T *type);
 int generate_STORE_THIS(cctx_T *cctx, int idx);
-int may_generate_2STRING(int offset, int tolerant, cctx_T *cctx);
+int may_generate_2STRING(int offset, int tostring_flags, cctx_T *cctx);
 int generate_add_instr(cctx_T *cctx, vartype_T vartype, type_T *type1, type_T *type2, exprtype_T expr_type);
 vartype_T operator_type(type_T *type1, type_T *type2);
 int generate_two_op(cctx_T *cctx, char_u *op);

src/testdir/test_expr.vim

@@ -953,6 +953,18 @@ func Test_string_interp()
     #" Dict interpolation
     VAR d = {'a': 10, 'b': [1, 2]}
     call assert_equal("{'a': 10, 'b': [1, 2]}", $'{d}')
+    VAR emptydict = {}
+    call assert_equal("a{}b", $'a{emptydict}b')
+    VAR nulldict = test_null_dict()
+    call assert_equal("a{}b", $'a{nulldict}b')
+
+    #" List interpolation
+    VAR l = ['a', 'b', 'c']
+    call assert_equal("['a', 'b', 'c']", $'{l}')
+    VAR emptylist = []
+    call assert_equal("a[]b", $'a{emptylist}b')
+    VAR nulllist = test_null_list()
+    call assert_equal("a[]b", $'a{nulllist}b')
 
     #" Stray closing brace.
     call assert_fails('echo $"moo}"', 'E1278:')

src/testdir/test_let.vim

@@ -696,6 +696,41 @@ END
   END
   call assert_equal(["let d2 = {'a': 10, 'b': 'ss', 'c': {}}"], code)
 
+  " Empty dictionary
+  let d1 = {}
+  let code =<< eval trim END
+    let d2 = {d1}
+  END
+  call assert_equal(["let d2 = {}"], code)
+
+  " null dictionary
+  let d1 = test_null_dict()
+  let code =<< eval trim END
+    let d2 = {d1}
+  END
+  call assert_equal(["let d2 = {}"], code)
+
+  " Evaluate a List
+  let l1 = ['a', 'b', 'c']
+  let code =<< eval trim END
+    let l2 = {l1}
+  END
+  call assert_equal(["let l2 = ['a', 'b', 'c']"], code)
+
+  " Empty List
+  let l1 = []
+  let code =<< eval trim END
+    let l2 = {l1}
+  END
+  call assert_equal(["let l2 = []"], code)
+
+  " Null List
+  let l1 = test_null_list()
+  let code =<< eval trim END
+    let l2 = {l1}
+  END
+  call assert_equal(["let l2 = []"], code)
+
   let code = 'xxx'
   let code =<< eval trim END
     let n = {5 +

src/testdir/test_put.vim

@@ -328,4 +328,12 @@ func Test_put_dict()
   bw!
 endfunc
 
+func Test_put_list()
+  new
+  let l = ['a', 'b', 'c']
+  put! =l
+  call assert_equal(['a', 'b', 'c', ''], getline(1, '$'))
+  bw!
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab

src/testdir/test_vim9_assign.vim

@@ -2994,6 +2994,56 @@ def Test_heredoc_expr()
   CODE
   v9.CheckDefAndScriptSuccess(lines)
 
+  # Evaluate an empty dictionary
+  lines =<< trim CODE
+    var d1 = {}
+    var code =<< trim eval END
+      var d2 = {d1}
+    END
+    assert_equal(["var d2 = {}"], code)
+  CODE
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # Evaluate a null dictionary
+  lines =<< trim CODE
+    var d1 = test_null_dict()
+    var code =<< trim eval END
+      var d2 = {d1}
+    END
+    assert_equal(["var d2 = {}"], code)
+  CODE
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # Evaluate a List
+  lines =<< trim CODE
+    var l1 = ['a', 'b', 'c']
+    var code =<< trim eval END
+      var l2 = {l1}
+    END
+    assert_equal(["var l2 = ['a', 'b', 'c']"], code)
+  CODE
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # Evaluate an empty List
+  lines =<< trim CODE
+    var l1 = []
+    var code =<< trim eval END
+      var l2 = {l1}
+    END
+    assert_equal(["var l2 = []"], code)
+  CODE
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # Evaluate a null List
+  lines =<< trim CODE
+    var l1 = test_null_list()
+    var code =<< trim eval END
+      var l2 = {l1}
+    END
+    assert_equal(["var l2 = []"], code)
+  CODE
+  v9.CheckDefAndScriptSuccess(lines)
+
   lines =<< trim CODE
     var code =<< eval trim END
       var s = "{$SOME_ENV_VAR}"

src/version.c

@@ -704,6 +704,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    335,
 /**/
     334,
 /**/

src/vim9.h

@@ -460,7 +460,7 @@ typedef struct {
 // arguments to ISN_2STRING and ISN_2STRING_ANY
 typedef struct {
     int		offset;
-    int		tolerant;
+    int		flags;
 } tostring_T;
 
 // arguments to ISN_2BOOL
@@ -880,3 +880,10 @@ typedef enum {
 
 // flags for call_def_function()
 #define DEF_USE_PT_ARGV	    1	// use the partial arguments
+
+// Flag used for conversion to string by may_generate_2STRING()
+#define TOSTRING_NONE		0x0
+// Convert a List to series of values separated by newline
+#define TOSTRING_INTERPOLATE	0x1
+// Convert a List to a textual representation of the list "[...]"
+#define TOSTRING_TOLERANT	0x2