Merge remote-tracking branch 'origin/master' into lambda

1 files changed, 739 insertions, 617 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 49ce9f3144..57c2368523 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -1422,13 +1422,13 @@ void ex_let(exarg_T *eap)
   if (*expr != '=' && !(vim_strchr((char_u *)"+-.", *expr) != NULL
                         && expr[1] == '=')) {
     // ":let" without "=": list variables
-    if (*arg == '[')
+    if (*arg == '[') {
       EMSG(_(e_invarg));
-    else if (!ends_excmd(*arg))
-      /* ":let var1 var2" */
-      arg = list_arg_vars(eap, arg, &first);
-    else if (!eap->skip) {
-      /* ":let" */
+    } else if (!ends_excmd(*arg)) {
+      // ":let var1 var2"
+      arg = (char_u *)list_arg_vars(eap, (const char *)arg, &first);
+    } else if (!eap->skip) {
+      // ":let"
       list_glob_vars(&first);
       list_buf_vars(&first);
       list_win_vars(&first);
@@ -1612,7 +1612,8 @@ static char_u *skip_var_one(char_u *arg)
  * List variables for hashtab "ht" with prefix "prefix".
  * If "empty" is TRUE also list NULL strings as empty strings.
  */
-static void list_hashtable_vars(hashtab_T *ht, char_u *prefix, int empty, int *first)
+static void list_hashtable_vars(hashtab_T *ht, const char *prefix, int empty,
+                                int *first)
 {
   hashitem_T  *hi;
   dictitem_T  *di;
@@ -1621,11 +1622,12 @@ static void list_hashtable_vars(hashtab_T *ht, char_u *prefix, int empty, int *f
   todo = (int)ht->ht_used;
   for (hi = ht->ht_array; todo > 0 && !got_int; ++hi) {
     if (!HASHITEM_EMPTY(hi)) {
-      --todo;
+      todo--;
       di = HI2DI(hi);
       if (empty || di->di_tv.v_type != VAR_STRING
-          || di->di_tv.vval.v_string != NULL)
+          || di->di_tv.vval.v_string != NULL) {
         list_one_var(di, prefix, first);
+      }
     }
   }
 }
@@ -1635,7 +1637,7 @@ static void list_hashtable_vars(hashtab_T *ht, char_u *prefix, int empty, int *f
  */
 static void list_glob_vars(int *first)
 {
-  list_hashtable_vars(&globvarht, (char_u *)"", TRUE, first);
+  list_hashtable_vars(&globvarht, "", true, first);
 }
 
 /*
@@ -1643,14 +1645,13 @@ static void list_glob_vars(int *first)
  */
 static void list_buf_vars(int *first)
 {
-  char_u numbuf[NUMBUFLEN];
+  char numbuf[NUMBUFLEN];
 
-  list_hashtable_vars(&curbuf->b_vars->dv_hashtab, (char_u *)"b:",
-      TRUE, first);
+  list_hashtable_vars(&curbuf->b_vars->dv_hashtab, "b:", true, first);
 
-  sprintf((char *)numbuf, "%" PRId64, (int64_t)curbuf->b_changedtick);
-  list_one_var_a((char_u *)"b:", (char_u *)"changedtick", VAR_NUMBER,
-      numbuf, first);
+  snprintf(numbuf, sizeof(numbuf), "%d", curbuf->b_changedtick);
+  list_one_var_a("b:", "changedtick", sizeof("changedtick") - 1, VAR_NUMBER,
+                 numbuf, first);
 }
 
 /*
@@ -1658,8 +1659,7 @@ static void list_buf_vars(int *first)
  */
 static void list_win_vars(int *first)
 {
-  list_hashtable_vars(&curwin->w_vars->dv_hashtab,
-      (char_u *)"w:", TRUE, first);
+  list_hashtable_vars(&curwin->w_vars->dv_hashtab, "w:", true, first);
 }
 
 /*
@@ -1667,8 +1667,7 @@ static void list_win_vars(int *first)
  */
 static void list_tab_vars(int *first)
 {
-  list_hashtable_vars(&curtab->tp_vars->dv_hashtab,
-      (char_u *)"t:", TRUE, first);
+  list_hashtable_vars(&curtab->tp_vars->dv_hashtab, "t:", true, first);
 }
 
 /*
@@ -1676,7 +1675,7 @@ static void list_tab_vars(int *first)
  */
 static void list_vim_vars(int *first)
 {
-  list_hashtable_vars(&vimvarht, (char_u *)"v:", FALSE, first);
+  list_hashtable_vars(&vimvarht, "v:", false, first);
 }
 
 /*
@@ -1684,9 +1683,9 @@ static void list_vim_vars(int *first)
  */
 static void list_script_vars(int *first)
 {
-  if (current_SID > 0 && current_SID <= ga_scripts.ga_len)
-    list_hashtable_vars(&SCRIPT_VARS(current_SID),
-        (char_u *)"s:", FALSE, first);
+  if (current_SID > 0 && current_SID <= ga_scripts.ga_len) {
+    list_hashtable_vars(&SCRIPT_VARS(current_SID), "s:", false, first);
+  }
 }
 
 /*
@@ -1694,36 +1693,37 @@ static void list_script_vars(int *first)
  */
 static void list_func_vars(int *first)
 {
-  if (current_funccal != NULL)
-    list_hashtable_vars(&current_funccal->l_vars.dv_hashtab,
-        (char_u *)"l:", FALSE, first);
+  if (current_funccal != NULL) {
+    list_hashtable_vars(&current_funccal->l_vars.dv_hashtab, "l:", false,
+                        first);
+  }
 }
 
 /*
  * List variables in "arg".
  */
-static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first)
+static const char *list_arg_vars(exarg_T *eap, const char *arg, int *first)
 {
   int error = FALSE;
   int len;
-  char_u      *name;
-  char_u      *name_start;
-  char_u      *arg_subsc;
-  char_u      *tofree;
+  const char *name;
+  const char *name_start;
   typval_T tv;
 
   while (!ends_excmd(*arg) && !got_int) {
     if (error || eap->skip) {
-      arg = find_name_end(arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
+      arg = (const char *)find_name_end((char_u *)arg, NULL, NULL,
+                                        FNE_INCL_BR | FNE_CHECK_START);
       if (!ascii_iswhite(*arg) && !ends_excmd(*arg)) {
         emsg_severe = TRUE;
         EMSG(_(e_trailing));
         break;
       }
     } else {
-      /* get_name_len() takes care of expanding curly braces */
+      // get_name_len() takes care of expanding curly braces
       name_start = name = arg;
-      len = get_name_len(&arg, &tofree, TRUE, TRUE);
+      char *tofree;
+      len = get_name_len(&arg, &tofree, true, true);
       if (len <= 0) {
         /* This is mainly to keep test 49 working: when expanding
          * curly braces fails overrule the exception error message. */
@@ -1737,14 +1737,15 @@ static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first)
         if (tofree != NULL) {
           name = tofree;
         }
-        if (get_var_tv(name, len, &tv, NULL, true, false) == FAIL) {
+        if (get_var_tv((const char *)name, len, &tv, NULL, true, false)
+            == FAIL) {
           error = true;
         } else {
           // handle d.key, l[idx], f(expr)
-          arg_subsc = arg;
-          if (handle_subscript(&arg, &tv, TRUE, TRUE) == FAIL)
-            error = TRUE;
-          else {
+          const char *const arg_subsc = arg;
+          if (handle_subscript(&arg, &tv, true, true) == FAIL) {
+            error = true;
+          } else {
             if (arg == arg_subsc && len == 2 && name[1] == ':') {
               switch (*name) {
               case 'g': list_glob_vars(first); break;
@@ -1758,17 +1759,15 @@ static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first)
                 EMSG2(_("E738: Can't list variables for %s"), name);
               }
             } else {
-              int c;
-
-              char_u *s = (char_u *) encode_tv2echo(&tv, NULL);
-              c = *arg;
-              *arg = NUL;
-              list_one_var_a((char_u *)"",
-                  arg == arg_subsc ? name : name_start,
-                  tv.v_type,
-                  s == NULL ? (char_u *)"" : s,
-                  first);
-              *arg = c;
+              char *const s = encode_tv2echo(&tv, NULL);
+              const char *const used_name = (arg == arg_subsc
+                                             ? name
+                                             : name_start);
+              const ptrdiff_t name_size = (used_name == tofree
+                                           ? (ptrdiff_t)strlen(used_name)
+                                           : (arg - used_name));
+              list_one_var_a("", used_name, name_size,
+                             tv.v_type, s == NULL ? "" : s, first);
               xfree(s);
             }
             clear_tv(&tv);
@@ -1779,7 +1778,7 @@ static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first)
       xfree(tofree);
     }
 
-    arg = skipwhite(arg);
+    arg = (const char *)skipwhite((const char_u *)arg);
   }
 
   return arg;
@@ -1799,9 +1798,7 @@ ex_let_one (
     char_u *op                /* "+", "-", "."  or NULL*/
 )
 {
-  int c1;
   char_u      *name;
-  char_u      *p;
   char_u      *arg_end = NULL;
   int len;
   int opt_flags;
@@ -1815,18 +1812,18 @@ ex_let_one (
     ++arg;
     name = arg;
     len = get_env_len(&arg);
-    if (len == 0)
+    if (len == 0) {
       EMSG2(_(e_invarg2), name - 1);
-    else {
-      if (op != NULL && (*op == '+' || *op == '-'))
+    } else {
+      if (op != NULL && (*op == '+' || *op == '-')) {
         EMSG2(_(e_letwrong), op);
-      else if (endchars != NULL
-               && vim_strchr(endchars, *skipwhite(arg)) == NULL)
+      } else if (endchars != NULL
+                 && vim_strchr(endchars, *skipwhite(arg)) == NULL) {
         EMSG(_(e_letunexp));
-      else if (!check_secure()) {
-        c1 = name[len];
+      } else if (!check_secure()) {
+        const char_u c1 = name[len];
         name[len] = NUL;
-        p = get_tv_string_chk(tv);
+        char_u *p = get_tv_string_chk(tv);
         if (p != NULL && op != NULL && *op == '.') {
           char *s = vim_getenv((char *)name);
 
@@ -1850,43 +1847,41 @@ ex_let_one (
         xfree(tofree);
       }
     }
-  }
-  /*
-   * ":let &option = expr": Set option value.
-   * ":let &l:option = expr": Set local option value.
-   * ":let &g:option = expr": Set global option value.
-   */
-  else if (*arg == '&') {
-    /* Find the end of the name. */
-    p = find_option_end(&arg, &opt_flags);
-    if (p == NULL || (endchars != NULL
-                      && vim_strchr(endchars, *skipwhite(p)) == NULL))
+  // ":let &option = expr": Set option value.
+  // ":let &l:option = expr": Set local option value.
+  // ":let &g:option = expr": Set global option value.
+  } else if (*arg == '&') {
+    // Find the end of the name.
+    char *const p = (char *)find_option_end((const char **)&arg, &opt_flags);
+    if (p == NULL
+        || (endchars != NULL
+            && vim_strchr(endchars, *skipwhite((const char_u *)p)) == NULL)) {
       EMSG(_(e_letunexp));
-    else {
+    } else {
       long n;
       int opt_type;
       long numval;
-      char_u      *stringval = NULL;
-      char_u      *s;
+      char_u *stringval = NULL;
+      char_u *s;
 
-      c1 = *p;
+      const char c1 = *p;
       *p = NUL;
 
       n = get_tv_number(tv);
       s = get_tv_string_chk(tv);            /* != NULL if number or string */
       if (s != NULL && op != NULL && *op != '=') {
-        opt_type = get_option_value(arg, &numval,
-            &stringval, opt_flags);
+        opt_type = get_option_value(arg, &numval, &stringval, opt_flags);
         if ((opt_type == 1 && *op == '.')
-            || (opt_type == 0 && *op != '.'))
+            || (opt_type == 0 && *op != '.')) {
           EMSG2(_(e_letwrong), op);
-        else {
-          if (opt_type == 1) {          /* number */
-            if (*op == '+')
+        } else {
+          if (opt_type == 1) {  // number
+            if (*op == '+') {
               n = numval + n;
-            else
+            } else {
               n = numval - n;
-          } else if (opt_type == 0 && stringval != NULL) {     /* string */
+            }
+          } else if (opt_type == 0 && stringval != NULL) {  // string
             s = concat_str(stringval, s);
             xfree(stringval);
             stringval = s;
@@ -1895,7 +1890,7 @@ ex_let_one (
       }
       if (s != NULL) {
         set_option_value(arg, n, s, opt_flags);
-        arg_end = p;
+        arg_end = (char_u *)p;
       }
       *p = c1;
       xfree(stringval);
@@ -1915,7 +1910,7 @@ ex_let_one (
       char_u      *ptofree = NULL;
       char_u      *s;
 
-      p = get_tv_string_chk(tv);
+      char_u *p = get_tv_string_chk(tv);
       if (p != NULL && op != NULL && *op == '.') {
         s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
         if (s != NULL) {
@@ -1937,7 +1932,7 @@ ex_let_one (
   else if (eval_isnamec1(*arg) || *arg == '{') {
     lval_T lv;
 
-    p = get_lval(arg, tv, &lv, FALSE, FALSE, 0, FNE_CHECK_START);
+    char_u *const p = get_lval(arg, tv, &lv, false, false, 0, FNE_CHECK_START);
     if (p != NULL && lv.ll_name != NULL) {
       if (endchars != NULL && vim_strchr(endchars, *skipwhite(p)) == NULL)
         EMSG(_(e_letunexp));
@@ -2047,9 +2042,11 @@ get_lval (
 
   cc = *p;
   *p = NUL;
-  v = find_var(lp->ll_name, &ht, flags & GLV_NO_AUTOLOAD);
-  if (v == NULL && !quiet)
+  v = find_var((const char *)lp->ll_name, STRLEN(lp->ll_name), &ht,
+               flags & GLV_NO_AUTOLOAD);
+  if (v == NULL && !quiet) {
     EMSG2(_(e_undefvar), lp->ll_name);
+  }
   *p = cc;
   if (v == NULL)
     return NULL;
@@ -2309,7 +2306,7 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
 
         // handle +=, -= and .=
         di = NULL;
-        if (get_var_tv(lp->ll_name, (int)STRLEN(lp->ll_name),
+        if (get_var_tv((const char *)lp->ll_name, (int)STRLEN(lp->ll_name),
                        &tv, &di, true, false) == OK) {
           if ((di == NULL
                || (!var_check_ro(di->di_flags, lp->ll_name, false)
@@ -2785,7 +2782,7 @@ void ex_call(exarg_T *eap)
   // contents. For VAR_PARTIAL get its partial, unless we already have one
   // from trans_function_name().
   len = (int)STRLEN(tofree);
-  name = deref_func_name(tofree, &len,
+  name = deref_func_name((const char *)tofree, &len,
                          partial != NULL ? NULL : &partial, false);
 
   /* Skip white space to allow ":call func ()".  Not good, but required for
@@ -2823,9 +2820,10 @@ void ex_call(exarg_T *eap)
       break;
     }
 
-    /* Handle a function returning a Funcref, Dictionary or List. */
-    if (handle_subscript(&arg, &rettv, !eap->skip, TRUE) == FAIL) {
-      failed = TRUE;
+    // Handle a function returning a Funcref, Dictionary or List.
+    if (handle_subscript((const char **)&arg, &rettv, !eap->skip, true)
+        == FAIL) {
+      failed = true;
       break;
     }
 
@@ -3014,7 +3012,8 @@ int do_unlet(char_u *name, int forceit)
   dict_T      *d;
   dictitem_T  *di;
   dict_T *dict;
-  ht = find_var_ht_dict(name, &varname, &dict);
+  ht = find_var_ht_dict((const char *)name, STRLEN(name),
+                        (const char **)&varname, &dict);
 
   if (ht != NULL && *varname != NUL) {
     if (ht == &globvarht) {
@@ -3025,7 +3024,7 @@ int do_unlet(char_u *name, int forceit)
     } else if (ht == &compat_hashtab) {
         d = &vimvardict;
     } else {
-      di = find_var_in_ht(ht, *name, (char_u *)"", false);
+      di = find_var_in_ht(ht, *name, "", 0, false);
       d = di->di_tv.vval.v_dict;
     }
     if (d == NULL) {
@@ -3034,7 +3033,7 @@ int do_unlet(char_u *name, int forceit)
     }
     hi = hash_find(ht, varname);
     if (HASHITEM_EMPTY(hi)) {
-      hi = find_hi_in_scoped_ht(name, &ht);
+      hi = find_hi_in_scoped_ht((const char *)name, &ht);
     }
     if (hi != NULL && !HASHITEM_EMPTY(hi)) {
       di = HI2DI(hi);
@@ -3088,18 +3087,19 @@ static int do_lock_var(lval_T *lp, char_u *name_end, int deep, int lock)
     cc = *name_end;
     *name_end = NUL;
 
-    /* Normal name or expanded name. */
-    if (check_changedtick(lp->ll_name))
+    // Normal name or expanded name.
+    if (check_changedtick(lp->ll_name)) {
       ret = FAIL;
-    else {
-      di = find_var(lp->ll_name, NULL, TRUE);
-      if (di == NULL)
+    } else {
+      di = find_var((const char *)lp->ll_name, STRLEN(lp->ll_name), NULL, true);
+      if (di == NULL) {
         ret = FAIL;
-      else {
-        if (lock)
+      } else {
+        if (lock) {
           di->di_flags |= DI_FLAGS_LOCK;
-        else
+        } else {
           di->di_flags &= ~DI_FLAGS_LOCK;
+        }
         item_lock(&di->di_tv, deep, lock);
       }
     }
@@ -4280,9 +4280,10 @@ static int eval7(
     break;
 
   // Option value: &name
-  case '&':   ret = get_option_tv(arg, rettv, evaluate);
+  case '&': {
+    ret = get_option_tv((const char **)arg, rettv, evaluate);
     break;
-
+  }
   // Environment variable: $VAR.
   case '$':   ret = get_env_tv(arg, rettv, evaluate);
     break;
@@ -4318,7 +4319,7 @@ static int eval7(
     // Must be a variable or function name.
     // Can also be a curly-braces kind of name: {expr}.
     s = *arg;
-    len = get_name_len(arg, &alias, evaluate, true);
+    len = get_name_len((const char **)arg, (char **)&alias, evaluate, true);
     if (alias != NULL) {
       s = alias;
     }
@@ -4330,12 +4331,12 @@ static int eval7(
         partial_T *partial;
 
         if (!evaluate) {
-          check_vars(s, len);
+          check_vars((const char *)s, len);
         }
 
         // If "s" is the name of a variable of type VAR_FUNC
         // use its contents.
-        s = deref_func_name(s, &len, &partial, !evaluate);
+        s = deref_func_name((const char *)s, &len, &partial, !evaluate);
 
         // Invoke the function.
         ret = get_func_tv(s, len, rettv, arg,
@@ -4360,9 +4361,9 @@ static int eval7(
           ret = FAIL;
         }
       } else if (evaluate) {
-        ret = get_var_tv(s, len, rettv, NULL, true, false);
+        ret = get_var_tv((const char *)s, len, rettv, NULL, true, false);
       } else {
-        check_vars(s, len);
+        check_vars((const char *)s, len);
         ret = OK;
       }
     }
@@ -4374,7 +4375,7 @@ static int eval7(
   // Handle following '[', '(' and '.' for expr[expr], expr.name,
   // expr(expr).
   if (ret == OK) {
-    ret = handle_subscript(arg, rettv, evaluate, true);
+    ret = handle_subscript((const char **)arg, rettv, evaluate, true);
   }
 
   // Apply logical NOT and unary '-', from right to left, ignore '+'.
@@ -4675,35 +4676,32 @@ eval_index (
   return OK;
 }
 
-/*
- * Get an option value.
- * "arg" points to the '&' or '+' before the option name.
- * "arg" is advanced to character after the option name.
- * Return OK or FAIL.
- */
-static int 
-get_option_tv (
-    char_u **arg,
-    typval_T *rettv,     /* when NULL, only check if option exists */
-    int evaluate
-)
+/// Get an option value
+///
+/// @param[in,out]  arg  Points to the '&' or '+' before the option name. Is
+///                      advanced to the character after the option name.
+/// @param[out]  rettv  Location where result is saved.
+/// @param[in]  evaluate  If not true, rettv is not populated.
+///
+/// @return OK or FAIL.
+static int get_option_tv(const char **const arg, typval_T *const rettv,
+                         const bool evaluate)
+  FUNC_ATTR_NONNULL_ARG(1)
 {
-  char_u      *option_end;
   long numval;
   char_u      *stringval;
   int opt_type;
   int c;
-  int working = (**arg == '+');              /* has("+option") */
+  bool working = (**arg == '+');  // has("+option")
   int ret = OK;
   int opt_flags;
 
-  /*
-   * Isolate the option name and find its value.
-   */
-  option_end = find_option_end(arg, &opt_flags);
+  // Isolate the option name and find its value.
+  char *option_end = (char *)find_option_end(arg, &opt_flags);
   if (option_end == NULL) {
-    if (rettv != NULL)
+    if (rettv != NULL) {
       EMSG2(_("E112: Option name missing: %s"), *arg);
+    }
     return FAIL;
   }
 
@@ -4714,8 +4712,8 @@ get_option_tv (
 
   c = *option_end;
   *option_end = NUL;
-  opt_type = get_option_value(*arg, &numval,
-      rettv == NULL ? NULL : &stringval, opt_flags);
+  opt_type = get_option_value((char_u *)(*arg), &numval,
+                              rettv == NULL ? NULL : &stringval, opt_flags);
 
   if (opt_type == -3) {                 /* invalid name */
     if (rettv != NULL)
@@ -7266,53 +7264,55 @@ static VimLFuncDef *find_internal_func(const char *const name)
   return find_internal_func_gperf(name, len);
 }
 
-/// Check if "name" is a variable of type VAR_FUNC.  If so, return the function
-/// name it contains, otherwise return "name".
-/// If "partialp" is not NULL, and "name" is of type VAR_PARTIAL also set
-/// "partialp".
-static char_u *deref_func_name(
-    char_u *name, int *lenp,
-    partial_T **partialp, bool no_autoload
-)
+/// Return name of the function corresponding to `name`
+///
+/// If `name` points to variable that is either a function or partial then
+/// corresponding function name is returned. Otherwise it returns `name` itself.
+///
+/// @param[in]  name  Function name to check.
+/// @param[in,out]  lenp  Location where length of the returned name is stored.
+///                       Must be set to the length of the `name` argument.
+/// @param[out]  partialp  Location where partial will be stored if found
+///                        function appears to be a partial. May be NULL if this
+///                        is not needed.
+/// @param[in]  no_autoload  If true, do not source autoload scripts if function
+///                          was not found.
+///
+/// @return name of the function.
+static char_u *deref_func_name(const char *name, int *lenp,
+                               partial_T **const partialp, bool no_autoload)
+  FUNC_ATTR_NONNULL_ARG(1, 2)
 {
-  dictitem_T  *v;
-  int cc;
-  char_u *s;
-
   if (partialp != NULL) {
     *partialp = NULL;
   }
 
-  cc = name[*lenp];
-  name[*lenp] = NUL;
-  v = find_var(name, NULL, no_autoload);
-  name[*lenp] = cc;
+  dictitem_T *const v = find_var(name, (size_t)(*lenp), NULL, no_autoload);
   if (v != NULL && v->di_tv.v_type == VAR_FUNC) {
-    if (v->di_tv.vval.v_string == NULL) {
+    if (v->di_tv.vval.v_string == NULL) {  // just in case
       *lenp = 0;
-      return (char_u *)"";              /* just in case */
+      return (char_u *)"";
     }
-    s = v->di_tv.vval.v_string;
-    *lenp = (int)STRLEN(s);
-    return s;
+    *lenp = (int)STRLEN(v->di_tv.vval.v_string);
+    return v->di_tv.vval.v_string;
   }
 
   if (v != NULL && v->di_tv.v_type == VAR_PARTIAL) {
-    partial_T *pt = v->di_tv.vval.v_partial;
+    partial_T *const pt = v->di_tv.vval.v_partial;
 
-    if (pt == NULL) {
+    if (pt == NULL) {  // just in case
       *lenp = 0;
-      return (char_u *)"";  // just in case
+      return (char_u *)"";
     }
     if (partialp != NULL) {
       *partialp = pt;
     }
-    s = partial_name(pt);
+    char_u *s = partial_name(pt);
     *lenp = (int)STRLEN(s);
     return s;
   }
 
-  return name;
+  return (char_u *)name;
 }
 
 /*
@@ -7394,34 +7394,49 @@ get_func_tv (
   return ret;
 }
 
-#define ERROR_UNKNOWN   0
-#define ERROR_TOOMANY   1
-#define ERROR_TOOFEW    2
-#define ERROR_SCRIPT    3
-#define ERROR_DICT      4
-#define ERROR_NONE      5
-#define ERROR_OTHER     6
-#define ERROR_BOTH      7
-#define ERROR_DELETED   8
+typedef enum {
+  ERROR_UNKNOWN = 0,
+  ERROR_TOOMANY,
+  ERROR_TOOFEW,
+  ERROR_SCRIPT,
+  ERROR_DICT,
+  ERROR_NONE,
+  ERROR_OTHER,
+  ERROR_BOTH,
+  ERROR_DELETED,
+} FnameTransError;
+
 #define FLEN_FIXED 40
 
-/// In a script change <SID>name() and s:name() to K_SNR 123_name().
-/// Change <SNR>123_name() to K_SNR 123_name().
-/// Use "fname_buf[FLEN_FIXED + 1]" when it fits, otherwise allocate memory
-/// (slow).
-static char_u *
-fname_trans_sid(char_u *name, char_u *fname_buf, char_u **tofree, int *error) {
-  int llen;
+/// In a script transform script-local names into actually used names
+///
+/// Transforms "<SID>" and "s:" prefixes to `K_SNR {N}` (e.g. K_SNR "123") and
+/// "<SNR>" prefix to `K_SNR`. Uses `fname_buf` buffer that is supposed to have
+/// #FLEN_FIXED + 1 length when it fits, otherwise it allocates memory.
+///
+/// @param[in]  name  Name to transform.
+/// @param  fname_buf  Buffer to save resulting function name to, if it fits.
+///                    Must have at least #FLEN_FIXED + 1 length.
+/// @param[out]  tofree  Location where pointer to an allocated memory is saved
+///                      in case result does not fit into fname_buf.
+/// @param[out]  error  Location where error type is saved, @see
+///                     FnameTransError.
+///
+/// @return transformed name: either `fname_buf` or a pointer to an allocated
+///         memory.
+static char_u *fname_trans_sid(const char_u *const name,
+                               char_u *const fname_buf,
+                               char_u **const tofree, int *const error)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
   char_u *fname;
-  int i;
-
-  llen = eval_fname_script(name);
+  const int llen = eval_fname_script((const char *)name);
   if (llen > 0) {
     fname_buf[0] = K_SPECIAL;
     fname_buf[1] = KS_EXTRA;
     fname_buf[2] = (int)KE_SNR;
-    i = 3;
-    if (eval_fname_sid(name)) {  // "<SID>" or "s:"
+    int i = 3;
+    if (eval_fname_sid((const char *)name)) {  // "<SID>" or "s:"
       if (current_SID <= 0) {
         *error = ERROR_SCRIPT;
       } else {
@@ -7444,7 +7459,7 @@ fname_trans_sid(char_u *name, char_u *fname_buf, char_u **tofree, int *error) {
       }
     }
   } else {
-    fname = name;
+    fname = (char_u *)name;
   }
 
   return fname;
@@ -7564,7 +7579,7 @@ call_func(
     rettv->vval.v_number = 0;
     error = ERROR_UNKNOWN;
 
-    if (!builtin_function(rfname, -1)) {
+    if (!builtin_function((const char *)rfname, -1)) {
       // User defined function.
       if (partial != NULL && partial->pt_func != NULL) {
         fp = partial->pt_func;
@@ -7579,9 +7594,10 @@ call_func(
         /* executed an autocommand, search for the function again */
         fp = find_func(rfname);
       }
-      /* Try loading a package. */
-      if (fp == NULL && script_autoload(rfname, TRUE) && !aborting()) {
-        /* loaded a package, search for the function again */
+      // Try loading a package.
+      if (fp == NULL && script_autoload((const char *)rfname, STRLEN(rfname),
+                                        true) && !aborting()) {
+        // Loaded a package, search for the function again.
         fp = find_func(rfname);
       }
 
@@ -7609,7 +7625,7 @@ call_func(
       }
     } else {
       // Find the function name in the table, call its implementation.
-      VimLFuncDef *const fdef = find_internal_func((char *)fname);
+      VimLFuncDef *const fdef = find_internal_func((const char *)fname);
       if (fdef != NULL) {
         if (argcount < fdef->min_argc) {
           error = ERROR_TOOFEW;
@@ -8292,17 +8308,17 @@ static buf_T *get_buf_tv(typval_T *tv, int curtab_only)
  */
 static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  buf_T       *buf;
-
-  (void)get_tv_number(&argvars[0]);         /* issue errmsg if type error */
-  ++emsg_off;
-  buf = get_buf_tv(&argvars[0], FALSE);
   rettv->v_type = VAR_STRING;
-  if (buf != NULL && buf->b_fname != NULL)
-    rettv->vval.v_string = vim_strsave(buf->b_fname);
-  else
-    rettv->vval.v_string = NULL;
-  --emsg_off;
+  rettv->vval.v_string = NULL;
+  if (!tv_check_str_or_nr(&argvars[0])) {
+    return;
+  }
+  emsg_off++;
+  const buf_T *const buf = get_buf_tv(&argvars[0], false);
+  emsg_off--;
+  if (buf != NULL && buf->b_fname != NULL) {
+    rettv->vval.v_string = (char_u *)xstrdup((char *)buf->b_fname);
+  }
 }
 
 /*
@@ -8310,36 +8326,36 @@ static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  buf_T       *buf;
-  int error = FALSE;
-  char_u      *name;
+  int error = false;
+  char_u *name;
 
-  (void)get_tv_number(&argvars[0]);         /* issue errmsg if type error */
-  ++emsg_off;
-  buf = get_buf_tv(&argvars[0], FALSE);
-  --emsg_off;
+  rettv->vval.v_number = -1;
+  if (!tv_check_str_or_nr(&argvars[0])) {
+    return;
+  }
+  emsg_off++;
+  const buf_T *buf = get_buf_tv(&argvars[0], false);
+  emsg_off--;
 
-  /* If the buffer isn't found and the second argument is not zero create a
-   * new buffer. */
+  // If the buffer isn't found and the second argument is not zero create a
+  // new buffer.
   if (buf == NULL
       && argvars[1].v_type != VAR_UNKNOWN
       && get_tv_number_chk(&argvars[1], &error) != 0
       && !error
       && (name = get_tv_string_chk(&argvars[0])) != NULL
-      && !error)
+      && !error) {
     buf = buflist_new(name, NULL, (linenr_T)1, 0);
+  }
 
-  if (buf != NULL)
+  if (buf != NULL) {
     rettv->vval.v_number = buf->b_fnum;
-  else
-    rettv->vval.v_number = -1;
+  }
 }
 
 static void buf_win_common(typval_T *argvars, typval_T *rettv, bool get_nr)
 {
-  int error = false;
-  (void)get_tv_number_chk(&argvars[0], &error);  // issue errmsg if type error
-  if (error) {  // the argument has an invalid type
+  if (!tv_check_str_or_nr(&argvars[0])) {
     rettv->vval.v_number = -1;
     return;
   }
@@ -8383,14 +8399,13 @@ static void f_bufwinnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_byte2line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  long boff = 0;
-
-  boff = get_tv_number(&argvars[0]) - 1;    /* boff gets -1 on type error */
-  if (boff < 0)
+  long boff = get_tv_number(&argvars[0]) - 1;
+  if (boff < 0) {
     rettv->vval.v_number = -1;
-  else
-    rettv->vval.v_number = ml_find_line_or_offset(curbuf,
-        (linenr_T)0, &boff);
+  } else {
+    rettv->vval.v_number = (varnumber_T)ml_find_line_or_offset(curbuf, 0,
+                                                               &boff);
+  }
 }
 
 static void byteidx(typval_T *argvars, typval_T *rettv, int comp)
@@ -9250,54 +9265,55 @@ static void f_exepath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *p;
-  char_u      *name;
-  int n = FALSE;
+  int n = false;
   int len = 0;
 
-  p = get_tv_string(&argvars[0]);
-  if (*p == '$') {                      /* environment variable */
-    /* first try "normal" environment variables (fast) */
-    if (os_getenv((char *)(p + 1)) != NULL)
-      n = TRUE;
-    else {
-      /* try expanding things like $VIM and ${HOME} */
-      p = expand_env_save(p);
-      if (p != NULL && *p != '$')
-        n = TRUE;
+  char *p = (char *)get_tv_string(&argvars[0]);
+  if (*p == '$') {  // Environment variable.
+    // First try "normal" environment variables (fast).
+    if (os_getenv(p + 1) != NULL) {
+      n = true;
+    } else {
+      // Try expanding things like $VIM and ${HOME}.
+      p = (char *)expand_env_save((char_u *)p);
+      if (p != NULL && *p != '$') {
+        n = true;
+      }
       xfree(p);
     }
-  } else if (*p == '&' || *p == '+') {                // option
-    n = (get_option_tv(&p, NULL, true) == OK);
-    if (*skipwhite(p) != NUL) {
-      n = false;               // trailing garbage
+  } else if (*p == '&' || *p == '+') {  // Option.
+    n = (get_option_tv((const char **)&p, NULL, true) == OK);
+    if (*skipwhite((const char_u *)p) != NUL) {
+      n = false;  // Trailing garbage.
     }
-  } else if (*p == '*') {             // internal or user defined function
+  } else if (*p == '*') {  // Internal or user defined function.
     n = function_exists(p + 1, false);
   } else if (*p == ':') {
     n = cmd_exists(p + 1);
   } else if (*p == '#') {
-    if (p[1] == '#')
+    if (p[1] == '#') {
       n = autocmd_supported(p + 2);
-    else
+    } else {
       n = au_exists(p + 1);
-  } else {                            /* internal variable */
-    char_u      *tofree;
+    }
+  } else {  // Internal variable.
     typval_T tv;
 
-    /* get_name_len() takes care of expanding curly braces */
-    name = p;
-    len = get_name_len(&p, &tofree, TRUE, FALSE);
+    // get_name_len() takes care of expanding curly braces
+    const char *name = p;
+    char *tofree;
+    len = get_name_len((const char **)&p, &tofree, true, false);
     if (len > 0) {
       if (tofree != NULL) {
         name = tofree;
       }
       n = (get_var_tv(name, len, &tv, NULL, false, true) == OK);
       if (n) {
-        /* handle d.key, l[idx], f(expr) */
-        n = (handle_subscript(&p, &tv, TRUE, FALSE) == OK);
-        if (n)
+        // Handle d.key, l[idx], f(expr).
+        n = (handle_subscript((const char **)&p, &tv, true, false) == OK);
+        if (n) {
           clear_tv(&tv);
+        }
       }
     }
     if (*p != NUL)
@@ -10055,7 +10071,7 @@ static void common_function(typval_T *argvars, typval_T *rettv,
     // Don't check an autoload name for existence here.
   } else if (trans_name != NULL
              && (is_funcref ? find_func(trans_name) == NULL
-                 : !translated_function_exists(trans_name))) {
+                 : !translated_function_exists((const char *)trans_name))) {
     EMSG2(_("E700: Unknown function: %s"), s);
   } else {
     int dict_idx = 0;
@@ -10451,20 +10467,22 @@ static void f_getbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   linenr_T lnum;
   linenr_T end;
-  buf_T       *buf;
+  buf_T *buf = NULL;
 
-  (void)get_tv_number(&argvars[0]);         /* issue errmsg if type error */
-  ++emsg_off;
-  buf = get_buf_tv(&argvars[0], FALSE);
-  --emsg_off;
+  if (tv_check_str_or_nr(&argvars[0])) {
+    emsg_off++;
+    buf = get_buf_tv(&argvars[0], false);
+    emsg_off--;
+  }
 
   lnum = get_tv_lnum_buf(&argvars[1], buf);
-  if (argvars[2].v_type == VAR_UNKNOWN)
+  if (argvars[2].v_type == VAR_UNKNOWN) {
     end = lnum;
-  else
+  } else {
     end = get_tv_lnum_buf(&argvars[2], buf);
+  }
 
-  get_buffer_lines(buf, lnum, end, TRUE, rettv);
+  get_buffer_lines(buf, lnum, end, true, rettv);
 }
 
 /*
@@ -10472,26 +10490,25 @@ static void f_getbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  buf_T       *buf;
-  buf_T       *save_curbuf;
-  char_u      *varname;
-  dictitem_T  *v;
-  int done = FALSE;
-
-  (void)get_tv_number(&argvars[0]);         /* issue errmsg if type error */
-  varname = get_tv_string_chk(&argvars[1]);
-  ++emsg_off;