vim-patch:8.2.{0695,0725,0734,0753,0818,0819,0822} (#23075)

vim-patch:8.2.0695: Vim9: cannot define a function inside a function

Problem:    Vim9: cannot define a function inside a function.
Solution:   Initial support for :def inside :def.

https://github.com/vim/vim/commit/04b12697838b232b8b17c553ccc74cf1f1bdb81c

vim-patch:8.2.0725: Vim9: cannot call a function declared later in Vim9 script

Problem:    Vim9: cannot call a function declared later in Vim9 script.
Solution:   Make two passes through the script file.

https://github.com/vim/vim/commit/09689a02840be40fa7bb10b1921fb5bc5b2908f1

vim-patch:8.2.0734: Vim9: leaking memory when using :finish

Problem:    Vim9: leaking memory when using :finish.
Solution:   Do not check for next line in third pass.

https://github.com/vim/vim/commit/04816717dfea6e2469ff4c9d40f68b59aaf03724

vim-patch:8.2.0753: Vim9: expressions are evaluated in the discovery phase

Problem:    Vim9: expressions are evaluated in the discovery phase.
Solution:   Bail out if an expression is not a constant.  Require a type for
            declared constants.

https://github.com/vim/vim/commit/32e351179eacfc84f64cd5029e221582d400bb38

vim-patch:8.2.0818: Vim9: using a discovery phase doesn't work well

Problem:    Vim9: using a discovery phase doesn't work well.
Solution:   Remove the discovery phase, instead compile a function only when
            it is used.  Add :defcompile to compile def functions earlier.

https://github.com/vim/vim/commit/822ba24743af9ee1b5e7f656a7a61a38f3638bca

vim-patch:8.2.0819: compiler warning for unused variable

Problem:    Compiler warning for unused variable.
Solution:   Remove the variable.

https://github.com/vim/vim/commit/f40e51a880a95f94dbbbecc9476559506c2cc345

vim-patch:8.2.0822: Vim9: code left over from discovery phase

Problem:    Vim9: code left over from discovery phase.
Solution:   Remove the dead code.

https://github.com/vim/vim/commit/2eec37926db6d31beb36f162ac00357a30c093c8

Co-authored-by: Bram Moolenaar <Bram@vim.org>

1 files changed, 79 insertions, 65 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index ff33fdeccb..796c010f74 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -706,7 +706,7 @@ int eval_to_bool(char *arg, bool *error, char **nextcmd, int skip)
   if (skip) {
     emsg_skip++;
   }
-  if (eval0(arg, &tv, nextcmd, !skip) == FAIL) {
+  if (eval0(arg, &tv, nextcmd, skip ? 0 : EVAL_EVALUATE) == FAIL) {
     *error = true;
   } else {
     *error = false;
@@ -730,7 +730,7 @@ static int eval1_emsg(char **arg, typval_T *rettv, bool evaluate)
   const int did_emsg_before = did_emsg;
   const int called_emsg_before = called_emsg;
 
-  const int ret = eval1(arg, rettv, evaluate);
+  const int ret = eval1(arg, rettv, evaluate ? EVAL_EVALUATE : 0);
   if (ret == FAIL) {
     // Report the invalid expression unless the expression evaluation has
     // been cancelled due to an aborting error, an interrupt, or an
@@ -832,7 +832,7 @@ char *eval_to_string_skip(const char *arg, const char **nextcmd, const bool skip
   if (skip) {
     emsg_skip++;
   }
-  if (eval0((char *)arg, &tv, (char **)nextcmd, !skip) == FAIL || skip) {
+  if (eval0((char *)arg, &tv, (char **)nextcmd, skip ? 0 : EVAL_EVALUATE) == FAIL || skip) {
     retval = NULL;
   } else {
     retval = xstrdup(tv_get_string(&tv));
@@ -853,7 +853,7 @@ int skip_expr(char **pp)
   typval_T rettv;
 
   *pp = skipwhite(*pp);
-  return eval1(pp, &rettv, false);
+  return eval1(pp, &rettv, 0);
 }
 
 /// Top level evaluation function, returning a string.
@@ -868,7 +868,7 @@ char *eval_to_string(char *arg, char **nextcmd, bool convert)
   char *retval;
   garray_T ga;
 
-  if (eval0(arg, &tv, nextcmd, true) == FAIL) {
+  if (eval0(arg, &tv, nextcmd, EVAL_EVALUATE) == FAIL) {
     retval = NULL;
   } else {
     if (convert && tv.v_type == VAR_LIST) {
@@ -929,7 +929,7 @@ varnumber_T eval_to_number(char *expr)
 
   emsg_off++;
 
-  if (eval1(&p, &rettv, true) == FAIL) {
+  if (eval1(&p, &rettv, EVAL_EVALUATE) == FAIL) {
     retval = -1;
   } else {
     retval = tv_get_number_chk(&rettv, NULL);
@@ -947,7 +947,7 @@ varnumber_T eval_to_number(char *expr)
 typval_T *eval_expr(char *arg)
 {
   typval_T *tv = xmalloc(sizeof(*tv));
-  if (eval0(arg, tv, NULL, true) == FAIL) {
+  if (eval0(arg, tv, NULL, EVAL_EVALUATE) == FAIL) {
     XFREE_CLEAR(tv);
   }
   return tv;
@@ -1024,7 +1024,7 @@ list_T *eval_spell_expr(char *badword, char *expr)
     emsg_off++;
   }
 
-  if (eval1(&p, &rettv, true) == OK) {
+  if (eval1(&p, &rettv, EVAL_EVALUATE) == OK) {
     if (rettv.v_type != VAR_LIST) {
       tv_clear(&rettv);
     } else {
@@ -1171,7 +1171,7 @@ int eval_foldexpr(char *arg, int *cp)
   }
   textlock++;
   *cp = NUL;
-  if (eval0(arg, &tv, NULL, true) == FAIL) {
+  if (eval0(arg, &tv, NULL, EVAL_EVALUATE) == FAIL) {
     retval = 0;
   } else {
     // If the result is a number, just return the number.
@@ -1346,7 +1346,7 @@ char *get_lval(char *const name, typval_T *const rettv, lval_T *const lp, const
         empty1 = true;
       } else {
         empty1 = false;
-        if (eval1(&p, &var1, true) == FAIL) {  // Recursive!
+        if (eval1(&p, &var1, EVAL_EVALUATE) == FAIL) {  // Recursive!
           return NULL;
         }
         if (!tv_check_str(&var1)) {
@@ -1380,7 +1380,8 @@ char *get_lval(char *const name, typval_T *const rettv, lval_T *const lp, const
           lp->ll_empty2 = true;
         } else {
           lp->ll_empty2 = false;
-          if (eval1(&p, &var2, true) == FAIL) {  // Recursive!
+          // Recursive!
+          if (eval1(&p, &var2, EVAL_EVALUATE) == FAIL) {
             tv_clear(&var1);
             return NULL;
           }
@@ -1799,7 +1800,7 @@ void *eval_for_line(const char *arg, bool *errp, char **nextcmdp, int skip)
   if (skip) {
     emsg_skip++;
   }
-  if (eval0(skipwhite(expr + 2), &tv, nextcmdp, !skip) == OK) {
+  if (eval0(skipwhite(expr + 2), &tv, nextcmdp, skip ? 0 : EVAL_EVALUATE) == OK) {
     *errp = false;
     if (!skip) {
       if (tv.v_type == VAR_LIST) {
@@ -2164,9 +2165,10 @@ int pattern_match(const char *pat, const char *text, bool ic)
 ///
 /// @return OK or FAIL.
 static int eval_func(char **const arg, char *const name, const int name_len, typval_T *const rettv,
-                     const bool evaluate, typval_T *const basetv)
+                     const int flags, typval_T *const basetv)
   FUNC_ATTR_NONNULL_ARG(1, 2, 4)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   char *s = name;
   int len = name_len;
 
@@ -2223,8 +2225,10 @@ static int eval_func(char **const arg, char *const name, const int name_len, typ
 /// Put the result in "rettv" when returning OK and "evaluate" is true.
 /// Note: "rettv.v_lock" is not set.
 ///
+/// @param flags  has EVAL_EVALUATE and similar flags.
+///
 /// @return OK or FAIL.
-int eval0(char *arg, typval_T *rettv, char **nextcmd, int evaluate)
+int eval0(char *arg, typval_T *rettv, char **nextcmd, const int flags)
 {
   int ret;
   char *p;
@@ -2233,7 +2237,7 @@ int eval0(char *arg, typval_T *rettv, char **nextcmd, int evaluate)
   bool end_error = false;
 
   p = skipwhite(arg);
-  ret = eval1(&p, rettv, evaluate);
+  ret = eval1(&p, rettv, flags);
 
   if (ret != FAIL) {
     end_error = !ends_excmd(*p);
@@ -2246,7 +2250,8 @@ int eval0(char *arg, typval_T *rettv, char **nextcmd, int evaluate)
     // been cancelled due to an aborting error, an interrupt, or an
     // exception, or we already gave a more specific error.
     // Also check called_emsg for when using assert_fails().
-    if (!aborting() && did_emsg == did_emsg_before
+    if (!aborting()
+        && did_emsg == did_emsg_before
         && called_emsg == called_emsg_before) {
       if (end_error) {
         semsg(_(e_trailing_arg), p);
@@ -2272,18 +2277,20 @@ int eval0(char *arg, typval_T *rettv, char **nextcmd, int evaluate)
 /// Note: "rettv.v_lock" is not set.
 ///
 /// @return  OK or FAIL.
-int eval1(char **arg, typval_T *rettv, int evaluate)
+int eval1(char **arg, typval_T *rettv, const int flags)
 {
   typval_T var2;
 
   // Get the first variable.
-  if (eval2(arg, rettv, evaluate) == FAIL) {
+  if (eval2(arg, rettv, flags) == FAIL) {
     return FAIL;
   }
 
   if ((*arg)[0] == '?') {
+    const bool evaluate = flags & EVAL_EVALUATE;
+
     bool result = false;
-    if (evaluate) {
+    if (flags & EVAL_EVALUATE) {
       bool error = false;
 
       if (tv_get_number_chk(rettv, &error) != 0) {
@@ -2295,9 +2302,9 @@ int eval1(char **arg, typval_T *rettv, int evaluate)
       }
     }
 
-    // Get the second variable.
+    // Get the second variable.  Recursive!
     *arg = skipwhite(*arg + 1);
-    if (eval1(arg, rettv, evaluate && result) == FAIL) {  // recursive!
+    if (eval1(arg, rettv, result ? flags : flags & ~EVAL_EVALUATE) == FAIL) {
       return FAIL;
     }
 
@@ -2310,9 +2317,9 @@ int eval1(char **arg, typval_T *rettv, int evaluate)
       return FAIL;
     }
 
-    // Get the third variable.
+    // Get the third variable.  Recursive!
     *arg = skipwhite(*arg + 1);
-    if (eval1(arg, &var2, evaluate && !result) == FAIL) {  // Recursive!
+    if (eval1(arg, &var2, !result ? flags : flags & ~EVAL_EVALUATE) == FAIL) {
       if (evaluate && result) {
         tv_clear(rettv);
       }
@@ -2333,13 +2340,13 @@ int eval1(char **arg, typval_T *rettv, int evaluate)
 /// "arg" is advanced to the next non-white after the recognized expression.
 ///
 /// @return  OK or FAIL.
-static int eval2(char **arg, typval_T *rettv, int evaluate)
+static int eval2(char **arg, typval_T *rettv, const int flags)
 {
   typval_T var2;
   bool error = false;
 
   // Get the first variable.
-  if (eval3(arg, rettv, evaluate) == FAIL) {
+  if (eval3(arg, rettv, flags) == FAIL) {
     return FAIL;
   }
 
@@ -2347,6 +2354,8 @@ static int eval2(char **arg, typval_T *rettv, int evaluate)
   bool first = true;
   bool result = false;
   while ((*arg)[0] == '|' && (*arg)[1] == '|') {
+    const bool evaluate = flags & EVAL_EVALUATE;
+
     if (evaluate && first) {
       if (tv_get_number_chk(rettv, &error) != 0) {
         result = true;
@@ -2360,7 +2369,7 @@ static int eval2(char **arg, typval_T *rettv, int evaluate)
 
     // Get the second variable.
     *arg = skipwhite(*arg + 2);
-    if (eval3(arg, &var2, evaluate && !result) == FAIL) {
+    if (eval3(arg, &var2, !result ? flags : flags & ~EVAL_EVALUATE) == FAIL) {
       return FAIL;
     }
 
@@ -2390,13 +2399,13 @@ static int eval2(char **arg, typval_T *rettv, int evaluate)
 ///             `arg` is advanced to the next non-white after the recognized expression.
 ///
 /// @return  OK or FAIL.
-static int eval3(char **arg, typval_T *rettv, int evaluate)
+static int eval3(char **arg, typval_T *rettv, const int flags)
 {
   typval_T var2;
   bool error = false;
 
   // Get the first variable.
-  if (eval4(arg, rettv, evaluate) == FAIL) {
+  if (eval4(arg, rettv, flags) == FAIL) {
     return FAIL;
   }
 
@@ -2404,6 +2413,8 @@ static int eval3(char **arg, typval_T *rettv, int evaluate)
   bool first = true;
   bool result = true;
   while ((*arg)[0] == '&' && (*arg)[1] == '&') {
+    const bool evaluate = flags & EVAL_EVALUATE;
+
     if (evaluate && first) {
       if (tv_get_number_chk(rettv, &error) == 0) {
         result = false;
@@ -2417,7 +2428,7 @@ static int eval3(char **arg, typval_T *rettv, int evaluate)
 
     // Get the second variable.
     *arg = skipwhite(*arg + 2);
-    if (eval4(arg, &var2, evaluate && result) == FAIL) {
+    if (eval4(arg, &var2, result ? flags : flags & ~EVAL_EVALUATE) == FAIL) {
       return FAIL;
     }
 
@@ -2456,7 +2467,7 @@ static int eval3(char **arg, typval_T *rettv, int evaluate)
 /// "arg" is advanced to the next non-white after the recognized expression.
 ///
 /// @return  OK or FAIL.
-static int eval4(char **arg, typval_T *rettv, int evaluate)
+static int eval4(char **arg, typval_T *rettv, const int flags)
 {
   typval_T var2;
   char *p;
@@ -2464,7 +2475,7 @@ static int eval4(char **arg, typval_T *rettv, int evaluate)
   int len = 2;
 
   // Get the first variable.
-  if (eval5(arg, rettv, evaluate) == FAIL) {
+  if (eval5(arg, rettv, flags) == FAIL) {
     return FAIL;
   }
 
@@ -2528,11 +2539,11 @@ static int eval4(char **arg, typval_T *rettv, int evaluate)
 
     // Get the second variable.
     *arg = skipwhite(p + len);
-    if (eval5(arg, &var2, evaluate) == FAIL) {
+    if (eval5(arg, &var2, flags) == FAIL) {
       tv_clear(rettv);
       return FAIL;
     }
-    if (evaluate) {
+    if (flags & EVAL_EVALUATE) {
       const int ret = typval_compare(rettv, &var2, type, ic);
 
       tv_clear(&var2);
@@ -2586,7 +2597,7 @@ static int eval_addlist(typval_T *tv1, typval_T *tv2)
 ///             `arg` is advanced to the next non-white after the recognized expression.
 ///
 /// @return  OK or FAIL.
-static int eval5(char **arg, typval_T *rettv, int evaluate)
+static int eval5(char **arg, typval_T *rettv, const int flags)
 {
   typval_T var2;
   varnumber_T n1, n2;
@@ -2594,7 +2605,7 @@ static int eval5(char **arg, typval_T *rettv, int evaluate)
   char *p;
 
   // Get the first variable.
-  if (eval6(arg, rettv, evaluate, false) == FAIL) {
+  if (eval6(arg, rettv, flags, false) == FAIL) {
     return FAIL;
   }
 
@@ -2606,7 +2617,7 @@ static int eval5(char **arg, typval_T *rettv, int evaluate)
     }
 
     if ((op != '+' || (rettv->v_type != VAR_LIST && rettv->v_type != VAR_BLOB))
-        && (op == '.' || rettv->v_type != VAR_FLOAT) && evaluate) {
+        && (op == '.' || rettv->v_type != VAR_FLOAT) && (flags & EVAL_EVALUATE)) {
       // For "list + ...", an illegal use of the first operand as
       // a number cannot be determined before evaluating the 2nd
       // operand: if this is also a list, all is ok.
@@ -2625,12 +2636,12 @@ static int eval5(char **arg, typval_T *rettv, int evaluate)
       (*arg)++;
     }
     *arg = skipwhite(*arg + 1);
-    if (eval6(arg, &var2, evaluate, op == '.') == FAIL) {
+    if (eval6(arg, &var2, flags, op == '.') == FAIL) {
       tv_clear(rettv);
       return FAIL;
     }
 
-    if (evaluate) {
+    if (flags & EVAL_EVALUATE) {
       // Compute the result.
       if (op == '.') {
         char buf1[NUMBUFLEN];
@@ -2724,11 +2735,10 @@ static int eval5(char **arg, typval_T *rettv, int evaluate)
 ///                      expression.  Is advanced to the next non-whitespace
 ///                      character after the recognized expression.
 /// @param[out]  rettv  Location where result is saved.
-/// @param[in]  evaluate  If not true, rettv is not populated.
 /// @param[in]  want_string  True if "." is string_concatenation, otherwise
 ///                          float
 /// @return  OK or FAIL.
-static int eval6(char **arg, typval_T *rettv, int evaluate, int want_string)
+static int eval6(char **arg, typval_T *rettv, const int flags, bool want_string)
   FUNC_ATTR_NO_SANITIZE_UNDEFINED
 {
   typval_T var2;
@@ -2739,7 +2749,7 @@ static int eval6(char **arg, typval_T *rettv, int evaluate, int want_string)
   bool error = false;
 
   // Get the first variable.
-  if (eval7(arg, rettv, evaluate, want_string) == FAIL) {
+  if (eval7(arg, rettv, flags, want_string) == FAIL) {
     return FAIL;
   }
 
@@ -2750,7 +2760,7 @@ static int eval6(char **arg, typval_T *rettv, int evaluate, int want_string)
       break;
     }
 
-    if (evaluate) {
+    if (flags & EVAL_EVALUATE) {
       if (rettv->v_type == VAR_FLOAT) {
         f1 = rettv->vval.v_float;
         use_float = true;
@@ -2768,11 +2778,11 @@ static int eval6(char **arg, typval_T *rettv, int evaluate, int want_string)
 
     // Get the second variable.
     *arg = skipwhite(*arg + 1);
-    if (eval7(arg, &var2, evaluate, false) == FAIL) {
+    if (eval7(arg, &var2, flags, false) == FAIL) {
       return FAIL;
     }
 
-    if (evaluate) {
+    if (flags & EVAL_EVALUATE) {
       if (var2.v_type == VAR_FLOAT) {
         if (!use_float) {
           f1 = (float_T)n1;
@@ -2859,8 +2869,9 @@ static int eval6(char **arg, typval_T *rettv, int evaluate, int want_string)
 /// @param want_string  after "." operator
 ///
 /// @return  OK or FAIL.
-static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
+static int eval7(char **arg, typval_T *rettv, const int flags, bool want_string)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   int ret = OK;
   static int recurse = 0;
 
@@ -2922,14 +2933,14 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
 
   // List: [expr, expr]
   case '[':
-    ret = get_list_tv(arg, rettv, evaluate);
+    ret = get_list_tv(arg, rettv, flags);
     break;
 
   // Dictionary: #{key: val, key: val}
   case '#':
     if ((*arg)[1] == '{') {
       (*arg)++;
-      ret = eval_dict(arg, rettv, evaluate, true);
+      ret = eval_dict(arg, rettv, flags, true);
     } else {
       ret = NOTDONE;
     }
@@ -2940,7 +2951,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
   case '{':
     ret = get_lambda_tv(arg, rettv, evaluate);
     if (ret == NOTDONE) {
-      ret = eval_dict(arg, rettv, evaluate, false);
+      ret = eval_dict(arg, rettv, flags, false);
     }
     break;
 
@@ -2968,7 +2979,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
   // nested expression: (expression).
   case '(':
     *arg = skipwhite(*arg + 1);
-    ret = eval1(arg, rettv, evaluate);                  // recursive!
+    ret = eval1(arg, rettv, flags);  // recursive!
     if (**arg == ')') {
       (*arg)++;
     } else if (ret == OK) {
@@ -2997,7 +3008,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
       ret = FAIL;
     } else {
       if (**arg == '(') {               // recursive!
-        ret = eval_func(arg, s, len, rettv, evaluate, NULL);
+        ret = eval_func(arg, s, len, rettv, flags, NULL);
       } else if (evaluate) {
         ret = get_var_tv(s, len, rettv, NULL, true, false);
       } else {
@@ -3013,7 +3024,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
   // Handle following '[', '(' and '.' for expr[expr], expr.name,
   // expr(expr), expr->name(expr)
   if (ret == OK) {
-    ret = handle_subscript((const char **)arg, rettv, evaluate, true);
+    ret = handle_subscript((const char **)arg, rettv, flags, true);
   }
 
   // Apply logical NOT and unary '-', from right to left, ignore '+'.
@@ -3238,7 +3249,7 @@ static int eval_method(char **const arg, typval_T *const rettv, const bool evalu
       }
       ret = call_func_rettv(arg, rettv, evaluate, NULL, &base, lua_funcname);
     } else {
-      ret = eval_func(arg, name, len, rettv, evaluate, &base);
+      ret = eval_func(arg, name, len, rettv, evaluate ? EVAL_EVALUATE : 0, &base);
     }
   }
 
@@ -3257,8 +3268,9 @@ static int eval_method(char **const arg, typval_T *const rettv, const bool evalu
 /// @param verbose  give error messages
 ///
 /// @returns FAIL or OK. "*arg" is advanced to after the ']'.
-static int eval_index(char **arg, typval_T *rettv, int evaluate, int verbose)
+static int eval_index(char **arg, typval_T *rettv, const int flags, bool verbose)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   bool empty1 = false;
   bool empty2 = false;
   ptrdiff_t len = -1;
@@ -3313,7 +3325,7 @@ static int eval_index(char **arg, typval_T *rettv, int evaluate, int verbose)
     *arg = skipwhite(*arg + 1);
     if (**arg == ':') {
       empty1 = true;
-    } else if (eval1(arg, &var1, evaluate) == FAIL) {  // Recursive!
+    } else if (eval1(arg, &var1, flags) == FAIL) {  // Recursive!
       return FAIL;
     } else if (evaluate && !tv_check_str(&var1)) {
       // Not a number or string.
@@ -3327,7 +3339,7 @@ static int eval_index(char **arg, typval_T *rettv, int evaluate, int verbose)
       *arg = skipwhite(*arg + 1);
       if (**arg == ']') {
         empty2 = true;
-      } else if (eval1(arg, &var2, evaluate) == FAIL) {  // Recursive!
+      } else if (eval1(arg, &var2, flags) == FAIL) {  // Recursive!
         if (!empty1) {
           tv_clear(&var1);
         }
@@ -3930,8 +3942,9 @@ void partial_unref(partial_T *pt)
 /// Allocate a variable for a List and fill it from "*arg".
 ///
 /// @return  OK or FAIL.
-static int get_list_tv(char **arg, typval_T *rettv, int evaluate)
+static int get_list_tv(char **arg, typval_T *rettv, const int flags)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   list_T *l = NULL;
 
   if (evaluate) {
@@ -3941,7 +3954,7 @@ static int get_list_tv(char **arg, typval_T *rettv, int evaluate)
   *arg = skipwhite(*arg + 1);
   while (**arg != ']' && **arg != NUL) {
     typval_T tv;
-    if (eval1(arg, &tv, evaluate) == FAIL) {  // Recursive!
+    if (eval1(arg, &tv, flags) == FAIL) {  // Recursive!
       goto failret;
     }
     if (evaluate) {
@@ -4576,8 +4589,9 @@ static int get_literal_key(char **arg, typval_T *tv)
 /// "literal" is true for #{key: val}
 ///
 /// @return  OK or FAIL.  Returns NOTDONE for {expr}.
-static int eval_dict(char **arg, typval_T *rettv, int evaluate, bool literal)
+static int eval_dict(char **arg, typval_T *rettv, const int flags, bool literal)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   typval_T tv;
   char *key = NULL;
   char *curly_expr = skipwhite(*arg + 1);
@@ -4591,7 +4605,7 @@ static int eval_dict(char **arg, typval_T *rettv, int evaluate, bool literal)
   // "#{abc}" is never a curly-braces expression.
   if (*curly_expr != '}'
       && !literal
-      && eval1(&curly_expr, &tv, false) == OK
+      && eval1(&curly_expr, &tv, 0) == OK
       && *skipwhite(curly_expr) == '}') {
     return NOTDONE;
   }
@@ -4608,7 +4622,7 @@ static int eval_dict(char **arg, typval_T *rettv, int evaluate, bool literal)
   while (**arg != '}' && **arg != NUL) {
     if ((literal
          ? get_literal_key(arg, &tvkey)
-         : eval1(arg, &tvkey, evaluate)) == FAIL) {  // recursive!
+         : eval1(arg, &tvkey, flags)) == FAIL) {  // recursive!
       goto failret;
     }
     if (**arg != ':') {
@@ -4626,7 +4640,7 @@ static int eval_dict(char **arg, typval_T *rettv, int evaluate, bool literal)
     }
 
     *arg = skipwhite(*arg + 1);
-    if (eval1(arg, &tv, evaluate) == FAIL) {  // Recursive!
+    if (eval1(arg, &tv, flags) == FAIL) {  // Recursive!
       if (evaluate) {
         tv_clear(&tvkey);
       }
@@ -6937,12 +6951,12 @@ int check_luafunc_name(const char *const str, const bool paren)
 ///
 /// Can all be combined in any order: dict.func(expr)[idx]['func'](expr)->len()
 ///
-/// @param evaluate  do more than finding the end
 /// @param verbose  give error messages
 /// @param start_leader  start of '!' and '-' prefixes
 /// @param end_leaderp  end of '!' and '-' prefixes
-int handle_subscript(const char **const arg, typval_T *rettv, int evaluate, int verbose)
+int handle_subscript(const char **const arg, typval_T *rettv, const int flags, bool verbose)
 {
+  const bool evaluate = flags & EVAL_EVALUATE;
   int ret = OK;
   dict_T *selfdict = NULL;
   const char *lua_funcname = NULL;
@@ -7002,7 +7016,7 @@ int handle_subscript(const char **const arg, typval_T *rettv, int evaluate, int
       } else {
         selfdict = NULL;
       }
-      if (eval_index((char **)arg, rettv, evaluate, verbose) == FAIL) {
+      if (eval_index((char **)arg, rettv, flags, verbose) == FAIL) {
         tv_clear(rettv);
         ret = FAIL;
       }
@@ -7385,7 +7399,7 @@ void ex_echo(exarg_T *eap)
 
     {
       char *p = arg;
-      if (eval1(&arg, &rettv, !eap->skip) == FAIL) {
+      if (eval1(&arg, &rettv, eap->skip ? 0 : EVAL_EVALUATE) == FAIL) {
         // Report the invalid expression unless the expression evaluation
         // has been cancelled due to an aborting error, an interrupt, or an
         // exception.