eval: Move remaining get_tv_string* functions to eval/typval.c

26 files changed, 1244 insertions, 1055 deletions

diff --git a/src/nvim/ascii.h b/src/nvim/ascii.h
index 31851a84e6..37b83efb61 100644
--- a/src/nvim/ascii.h
+++ b/src/nvim/ascii.h
@@ -20,15 +20,13 @@
 #define BS              '\010'
 #define TAB             '\011'
 #define NL              '\012'
-#define NL_STR          (char_u *)"\012"
+#define NL_STR          "\012"
 #define FF              '\014'
 #define CAR             '\015'  /* CR is used by Mac OS X */
 #define ESC             '\033'
-#define ESC_STR         (char_u *)"\033"
-#define ESC_STR_nc      "\033"
+#define ESC_STR         "\033"
 #define DEL             0x7f
-#define DEL_STR         (char_u *)"\177"
-#define CSI             0x9b    /* Control Sequence Introducer */
+#define CSI             0x9b    // Control Sequence Introducer
 #define CSI_STR         "\233"
 #define DCS             0x90    /* Device Control String */
 #define STERM           0x9c    /* String Terminator */
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index cb6a9fa43c..6c22108853 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -90,7 +90,6 @@ int buf_init_chartab(buf_T *buf, int global)
 {
   int c;
   int c2;
-  char_u *p;
   int i;
   bool tilde;
   bool do_isalpha;
@@ -144,7 +143,8 @@ int buf_init_chartab(buf_T *buf, int global)
   // Walk through the 'isident', 'iskeyword', 'isfname' and 'isprint'
   // options Each option is a list of characters, character numbers or
   // ranges, separated by commas, e.g.: "200-210,x,#-178,-"
-  for (i = global ? 0 : 3; i <= 3; ++i) {
+  for (i = global ? 0 : 3; i <= 3; i++) {
+    const char_u *p;
     if (i == 0) {
       // first round: 'isident'
       p = p_isi;
@@ -169,7 +169,7 @@ int buf_init_chartab(buf_T *buf, int global)
       }
 
       if (ascii_isdigit(*p)) {
-        c = getdigits_int(&p);
+        c = getdigits_int((char_u **)&p);
       } else {
         c = mb_ptr2char_adv(&p);
       }
@@ -179,7 +179,7 @@ int buf_init_chartab(buf_T *buf, int global)
         ++p;
 
         if (ascii_isdigit(*p)) {
-          c2 = getdigits_int(&p);
+          c2 = getdigits_int((char_u **)&p);
         } else {
           c2 = mb_ptr2char_adv(&p);
         }
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index b396251051..da09aed3dc 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1423,7 +1423,7 @@ static void ins_ctrl_v(void)
     edit_putchar('^', TRUE);
     did_putchar = TRUE;
   }
-  AppendToRedobuff((char_u *)CTRL_V_STR);       /* CTRL-V */
+  AppendToRedobuff(CTRL_V_STR);
 
   add_to_showcmd_c(Ctrl_V);
 
@@ -1977,7 +1977,6 @@ static bool ins_compl_accept_char(int c)
  */
 int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int dir, int flags)
 {
-  char_u      *p;
   int i, c;
   int actual_len;                       /* Take multi-byte characters */
   int actual_compl_length;              /* into account. */
@@ -1987,11 +1986,11 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
   int was_letter = FALSE;
 
   if (p_ic && curbuf->b_p_inf && len > 0) {
-    /* Infer case of completed part. */
+    // Infer case of completed part.
 
-    /* Find actual length of completion. */
+    // Find actual length of completion.
     if (has_mbyte) {
-      p = str;
+      const char_u *p = str;
       actual_len = 0;
       while (*p != NUL) {
         mb_ptr_adv(p);
@@ -2002,7 +2001,7 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
 
     /* Find actual length of original text. */
     if (has_mbyte) {
-      p = compl_orig_text;
+      const char_u *p = compl_orig_text;
       actual_compl_length = 0;
       while (*p != NUL) {
         mb_ptr_adv(p);
@@ -2018,27 +2017,35 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
 
     /* Allocate wide character array for the completion and fill it. */
     wca = xmalloc(actual_len * sizeof(*wca));
-    p = str;
-    for (i = 0; i < actual_len; ++i)
-      if (has_mbyte)
-        wca[i] = mb_ptr2char_adv(&p);
-      else
-        wca[i] = *(p++);
+    {
+      const char_u *p = str;
+      for (i = 0; i < actual_len; i++) {
+        if (has_mbyte) {
+          wca[i] = mb_ptr2char_adv(&p);
+        } else {
+          wca[i] = *(p++);
+        }
+      }
+    }
 
-    /* Rule 1: Were any chars converted to lower? */
-    p = compl_orig_text;
-    for (i = 0; i < min_len; ++i) {
-      if (has_mbyte)
-        c = mb_ptr2char_adv(&p);
-      else
-        c = *(p++);
-      if (vim_islower(c)) {
-        has_lower = TRUE;
-        if (vim_isupper(wca[i])) {
-          /* Rule 1 is satisfied. */
-          for (i = actual_compl_length; i < actual_len; ++i)
-            wca[i] = vim_tolower(wca[i]);
-          break;
+    // Rule 1: Were any chars converted to lower?
+    {
+      const char_u *p = compl_orig_text;
+      for (i = 0; i < min_len; i++) {
+        if (has_mbyte) {
+          c = mb_ptr2char_adv(&p);
+        } else {
+          c = *(p++);
+        }
+        if (vim_islower(c)) {
+          has_lower = true;
+          if (vim_isupper(wca[i])) {
+            // Rule 1 is satisfied.
+            for (i = actual_compl_length; i < actual_len; i++) {
+              wca[i] = vim_tolower(wca[i]);
+            }
+            break;
+          }
         }
       }
     }
@@ -2048,49 +2055,57 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
      * upper case.
      */
     if (!has_lower) {
-      p = compl_orig_text;
-      for (i = 0; i < min_len; ++i) {
-        if (has_mbyte)
+      const char_u *p = compl_orig_text;
+      for (i = 0; i < min_len; i++) {
+        if (has_mbyte) {
           c = mb_ptr2char_adv(&p);
-        else
+        } else {
           c = *(p++);
+        }
         if (was_letter && vim_isupper(c) && vim_islower(wca[i])) {
-          /* Rule 2 is satisfied. */
-          for (i = actual_compl_length; i < actual_len; ++i)
+          // Rule 2 is satisfied.
+          for (i = actual_compl_length; i < actual_len; i++) {
             wca[i] = vim_toupper(wca[i]);
+          }
           break;
         }
         was_letter = vim_islower(c) || vim_isupper(c);
       }
     }
 
-    /* Copy the original case of the part we typed. */
-    p = compl_orig_text;
-    for (i = 0; i < min_len; ++i) {
-      if (has_mbyte)
-        c = mb_ptr2char_adv(&p);
-      else
-        c = *(p++);
-      if (vim_islower(c))
-        wca[i] = vim_tolower(wca[i]);
-      else if (vim_isupper(c))
-        wca[i] = vim_toupper(wca[i]);
+    // Copy the original case of the part we typed.
+    {
+      const char_u *p = compl_orig_text;
+      for (i = 0; i < min_len; i++) {
+        if (has_mbyte) {
+          c = mb_ptr2char_adv(&p);
+        } else {
+          c = *(p++);
+        }
+        if (vim_islower(c)) {
+          wca[i] = vim_tolower(wca[i]);
+        } else if (vim_isupper(c)) {
+          wca[i] = vim_toupper(wca[i]);
+        }
+      }
     }
 
-    /*
-     * Generate encoding specific output from wide character array.
-     * Multi-byte characters can occupy up to five bytes more than
-     * ASCII characters, and we also need one byte for NUL, so stay
-     * six bytes away from the edge of IObuff.
-     */
-    p = IObuff;
-    i = 0;
-    while (i < actual_len && (p - IObuff + 6) < IOSIZE)
-      if (has_mbyte)
-        p += (*mb_char2bytes)(wca[i++], p);
-      else
-        *(p++) = wca[i++];
-    *p = NUL;
+    // Generate encoding specific output from wide character array.
+    // Multi-byte characters can occupy up to five bytes more than
+    // ASCII characters, and we also need one byte for NUL, so stay
+    // six bytes away from the edge of IObuff.
+    {
+      char_u *p = IObuff;
+      i = 0;
+      while (i < actual_len && (p - IObuff + 6) < IOSIZE) {
+        if (has_mbyte) {
+          p += (*mb_char2bytes)(wca[i++], p);
+        } else {
+          *(p++) = wca[i++];
+        }
+      }
+      *p = NUL;
+    }
 
     xfree(wca);
 
@@ -3594,7 +3609,7 @@ int ins_compl_add_tv(typval_T *const tv, const Direction dir)
     adup = (bool)tv_dict_get_number(tv->vval.v_dict, "dup");
     aempty = (bool)tv_dict_get_number(tv->vval.v_dict, "empty");
   } else {
-    word = (const char *)get_tv_string_chk(tv);
+    word = (const char *)tv_get_string_chk(tv);
     memset(cptext, 0, sizeof(cptext));
   }
   if (word == NULL || (!aempty && *word == NUL)) {
@@ -5785,15 +5800,16 @@ comp_textwidth (
  */
 static void redo_literal(int c)
 {
-  char_u buf[10];
+  char buf[10];
 
-  /* Only digits need special treatment.  Translate them into a string of
-   * three digits. */
+  // Only digits need special treatment.  Translate them into a string of
+  // three digits.
   if (ascii_isdigit(c)) {
-    vim_snprintf((char *)buf, sizeof(buf), "%03d", c);
+    vim_snprintf(buf, sizeof(buf), "%03d", c);
     AppendToRedobuff(buf);
-  } else
+  } else {
     AppendCharToRedobuff(c);
+  }
 }
 
 // start_arrow() is called when an arrow key is used in insert mode.
@@ -5822,8 +5838,8 @@ static void start_arrow_common(pos_T *end_insert_pos, bool end_change)
 {
   if (!arrow_used && end_change) {  // something has been inserted
     AppendToRedobuff(ESC_STR);
-    stop_insert(end_insert_pos, FALSE, FALSE);
-    arrow_used = TRUE;          /* this means we stopped the current insert */
+    stop_insert(end_insert_pos, false, false);
+    arrow_used = true;  // This means we stopped the current insert.
   }
   check_spell_redraw();
 }
@@ -5880,7 +5896,7 @@ int stop_arrow(void)
       vr_lines_changed = 1;
     }
     ResetRedobuff();
-    AppendToRedobuff((char_u *)"1i");       /* pretend we start an insertion */
+    AppendToRedobuff("1i");  // Pretend we start an insertion.
     new_insert_skip = 2;
   } else if (ins_need_undo) {
     if (u_save_cursor() == OK)
@@ -6345,12 +6361,13 @@ stuff_inserted (
   }
 
   do {
-    stuffReadbuff(ptr);
-    /* a trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^" */
-    if (last)
-      stuffReadbuff((char_u *)(last == '0'
-                               ? "\026\060\064\070"
-                               : "\026^"));
+    stuffReadbuff((const char *)ptr);
+    // A trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^".
+    if (last) {
+      stuffReadbuff((last == '0'
+                     ? "\026\060\064\070"
+                     : "\026^"));
+    }
   } while (--count > 0);
 
   if (last)
@@ -7143,13 +7160,12 @@ static bool ins_esc(long *count, int cmdchar, bool nomove)
     disabled_redraw = false;
   }
   if (!arrow_used) {
-    /*
-     * Don't append the ESC for "r<CR>" and "grx".
-     * When 'insertmode' is set only CTRL-L stops Insert mode.  Needed for
-     * when "count" is non-zero.
-     */
-    if (cmdchar != 'r' && cmdchar != 'v')
-      AppendToRedobuff(p_im ? (char_u *)"\014" : ESC_STR);
+    // Don't append the ESC for "r<CR>" and "grx".
+    // When 'insertmode' is set only CTRL-L stops Insert mode.  Needed for
+    // when "count" is non-zero.
+    if (cmdchar != 'r' && cmdchar != 'v') {
+      AppendToRedobuff(p_im ? "\014" : ESC_STR);
+    }
 
     /*
      * Repeating insert may take a long time.  Check for
@@ -7303,7 +7319,8 @@ static bool ins_start_select(int c)
     // Execute the key in (insert) Select mode.
     stuffcharReadbuff(Ctrl_O);
     if (mod_mask) {
-      char_u buf[4] = { K_SPECIAL, KS_MODIFIER, mod_mask, NUL };
+      const char buf[] = { (char)K_SPECIAL, (char)KS_MODIFIER,
+                           (char)(uint8_t)mod_mask, NUL };
       stuffReadbuff(buf);
     }
     stuffcharReadbuff(c);
@@ -8111,11 +8128,11 @@ static bool ins_tab(void)
     return true;
   }
 
-  did_ai = FALSE;
-  did_si = FALSE;
-  can_si = FALSE;
-  can_si_back = FALSE;
-  AppendToRedobuff((char_u *)"\t");
+  did_ai = false;
+  did_si = false;
+  can_si = false;
+  can_si_back = false;
+  AppendToRedobuff("\t");
 
   if (p_sta && ind) {  // insert tab in indent, use "shiftwidth"
     temp = get_sw_value(curbuf);
@@ -8380,8 +8397,8 @@ static int ins_digraph(void)
       edit_unputchar();
     }
     if (cc != ESC) {
-      AppendToRedobuff((char_u *)CTRL_V_STR);
-      c = getdigraph(c, cc, TRUE);
+      AppendToRedobuff(CTRL_V_STR);
+      c = getdigraph(c, cc, true);
       clear_showcmd();
       return c;
     }
@@ -8443,12 +8460,13 @@ static int ins_ctrl_ey(int tc)
     if (c != NUL) {
       long tw_save;
 
-      /* The character must be taken literally, insert like it
-       * was typed after a CTRL-V, and pretend 'textwidth'
-       * wasn't set.  Digits, 'o' and 'x' are special after a
-       * CTRL-V, don't use it for these. */
-      if (c < 256 && !isalnum(c))
-        AppendToRedobuff((char_u *)CTRL_V_STR);         /* CTRL-V */
+      // The character must be taken literally, insert like it
+      // was typed after a CTRL-V, and pretend 'textwidth'
+      // wasn't set.  Digits, 'o' and 'x' are special after a
+      // CTRL-V, don't use it for these.
+      if (c < 256 && !isalnum(c)) {
+        AppendToRedobuff(CTRL_V_STR);
+      }
       tw_save = curbuf->b_p_tw;
       curbuf->b_p_tw = -1;
       insert_special(c, TRUE, FALSE);
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 65bb90fc15..3a0075e48a 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -173,7 +173,6 @@ static char *e_funcref = N_("E718: Funcref required");
 static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
 static char *e_nofunc = N_("E130: Unknown function: %s");
 static char *e_illvar = N_("E461: Illegal variable name: %s");
-static char *e_float_as_string = N_("E806: using Float as a String");
 static const char *e_readonlyvar = N_(
     "E46: Cannot change read-only variable \"%.*s\"");
 
@@ -1852,7 +1851,6 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
                           const char_u *const op)
   FUNC_ATTR_NONNULL_ARG(1, 2) FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  char_u *name;
   char_u *arg_end = NULL;
   int len;
   int opt_flags;
@@ -1864,7 +1862,7 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
   if (*arg == '$') {
     // Find the end of the name.
     arg++;
-    name = arg;
+    char *name = (char *)arg;
     len = get_env_len((const char_u **)&arg);
     if (len == 0) {
       EMSG2(_(e_invarg2), name - 1);
@@ -1875,26 +1873,28 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
                  && vim_strchr(endchars, *skipwhite(arg)) == NULL) {
         EMSG(_(e_letunexp));
       } else if (!check_secure()) {
-        const char_u c1 = name[len];
+        const char c1 = name[len];
         name[len] = NUL;
-        char_u *p = get_tv_string_chk(tv);
+        const char *p = tv_get_string_chk(tv);
         if (p != NULL && op != NULL && *op == '.') {
-          char *s = vim_getenv((char *)name);
+          char *s = vim_getenv(name);
 
           if (s != NULL) {
-            p = tofree = concat_str((char_u *)s, p);
+            tofree = concat_str((const char_u *)s, (const char_u *)p);
+            p = (const char *)tofree;
             xfree(s);
           }
         }
         if (p != NULL) {
-          vim_setenv((char *)name, (char *)p);
-          if (STRICMP(name, "HOME") == 0)
+          vim_setenv(name, p);
+          if (STRICMP(name, "HOME") == 0) {
             init_homedir();
-          else if (didset_vim && STRICMP(name, "VIM") == 0)
-            didset_vim = FALSE;
-          else if (didset_vimruntime
-                   && STRICMP(name, "VIMRUNTIME") == 0)
-            didset_vimruntime = FALSE;
+          } else if (didset_vim && STRICMP(name, "VIM") == 0) {
+            didset_vim = false;
+          } else if (didset_vimruntime
+                     && STRICMP(name, "VIMRUNTIME") == 0) {
+            didset_vimruntime = false;
+          }
           arg_end = arg;
         }
         name[len] = c1;
@@ -1914,16 +1914,16 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
     } else {
       int opt_type;
       long numval;
-      char_u *stringval = NULL;
-      char_u *s;
+      char *stringval = NULL;
 
       const char c1 = *p;
       *p = NUL;
 
       varnumber_T n = tv_get_number(tv);
-      s = get_tv_string_chk(tv);  // != NULL if number or string.
+      const char *s = tv_get_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, (char_u **)&stringval,
+                                    opt_flags);
         if ((opt_type == 1 && *op == '.')
             || (opt_type == 0 && *op != '.')) {
           EMSG2(_(e_letwrong), op);
@@ -1935,44 +1935,45 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
               n = numval - n;
             }
           } else if (opt_type == 0 && stringval != NULL) {  // string
-            s = concat_str(stringval, s);
-            xfree(stringval);
-            stringval = s;
+            char *const oldstringval = stringval;
+            stringval = (char *)concat_str((const char_u *)stringval,
+                                           (const char_u *)s);
+            xfree(oldstringval);
+            s = stringval;
           }
         }
       }
       if (s != NULL) {
-        set_option_value((const char *)arg, n, (char *)s, opt_flags);
+        set_option_value((const char *)arg, n, s, opt_flags);
         arg_end = (char_u *)p;
       }
       *p = c1;
       xfree(stringval);
     }
-  }
-  /*
-   * ":let @r = expr": Set register contents.
-   */
-  else if (*arg == '@') {
-    ++arg;
-    if (op != NULL && (*op == '+' || *op == '-'))
-      EMSG2(_(e_letwrong), op);
-    else if (endchars != NULL
-             && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL)
-      EMSG(_(e_letunexp));
-    else {
-      char_u      *ptofree = NULL;
+  // ":let @r = expr": Set register contents.
+  } else if (*arg == '@') {
+    arg++;
+    if (op != NULL && (*op == '+' || *op == '-')) {
+      emsgf(_(e_letwrong), op);
+    } else if (endchars != NULL
+               && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) {
+      emsgf(_(e_letunexp));
+    } else {
       char_u      *s;
 
-      char_u *p = get_tv_string_chk(tv);
+      char_u *ptofree = NULL;
+      const char *p = tv_get_string_chk(tv);
       if (p != NULL && op != NULL && *op == '.') {
         s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
         if (s != NULL) {
-          p = ptofree = concat_str(s, p);
+          ptofree = concat_str(s, (const char_u *)p);
+          p = (const char *)ptofree;
           xfree(s);
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg, p, STRLEN(p), false);
+        write_reg_contents(*arg == '@' ? '"' : *arg,
+                           (const char_u *)p, STRLEN(p), false);
         arg_end = arg + 1;
       }
       xfree(ptofree);
@@ -2129,13 +2130,14 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
     } else {
       /* Get the index [expr] or the first index [expr: ]. */
       p = skipwhite(p + 1);
-      if (*p == ':')
-        empty1 = TRUE;
-      else {
-        empty1 = FALSE;
-        if (eval1(&p, &var1, TRUE) == FAIL)             /* recursive! */
+      if (*p == ':') {
+        empty1 = true;
+      } else {
+        empty1 = false;
+        if (eval1(&p, &var1, true) == FAIL) {  // Recursive!
           return NULL;
-        if (get_tv_string_chk(&var1) == NULL) {
+        }
+        if (!tv_check_str(&var1)) {
           // Not a number or string.
           tv_clear(&var1);
           return NULL;
@@ -2174,7 +2176,7 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
             }
             return NULL;
           }
-          if (get_tv_string_chk(&var2) == NULL) {
+          if (!tv_check_str(&var2)) {
             // Not a number or string.
             if (!empty1) {
               tv_clear(&var1);
@@ -3810,16 +3812,15 @@ static int eval5(char_u **arg, typval_T *rettv, int evaluate)
       break;
 
     if ((op != '+' || rettv->v_type != VAR_LIST)
-        && (op == '.' || rettv->v_type != VAR_FLOAT)
-        ) {
-      /* 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.
-       * For "something . ...", "something - ..." or "non-list + ...",
-       * we know that the first operand needs to be a string or number
-       * without evaluating the 2nd operand.  So check before to avoid
-       * side effects after an error. */
-      if (evaluate && get_tv_string_chk(rettv) == NULL) {
+        && (op == '.' || rettv->v_type != VAR_FLOAT)) {
+      // 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.
+      // For "something . ...", "something - ..." or "non-list + ...",
+      // we know that the first operand needs to be a string or number
+      // without evaluating the 2nd operand.  So check before to avoid
+      // side effects after an error.
+      if (evaluate && !tv_check_str(rettv)) {
         tv_clear(rettv);
         return FAIL;
       }
@@ -3840,10 +3841,10 @@ static int eval5(char_u **arg, typval_T *rettv, int evaluate)
        */
       if (op == '.') {
         char buf1[NUMBUFLEN];
-        char_u buf2[NUMBUFLEN];
+        char buf2[NUMBUFLEN];
         // s1 already checked
         const char *const s1 = tv_get_string_buf(rettv, buf1);
-        const char *const s2 = (const char *)get_tv_string_buf_chk(&var2, buf2);
+        const char *const s2 = tv_get_string_buf_chk(&var2, buf2);
         if (s2 == NULL) {  // Type error?
           tv_clear(rettv);
           tv_clear(&var2);
@@ -4411,7 +4412,7 @@ eval_index (
       empty1 = true;
     } else if (eval1(arg, &var1, evaluate) == FAIL) {  // Recursive!
       return FAIL;
-    } else if (evaluate && get_tv_string_chk(&var1) == NULL) {
+    } else if (evaluate && !tv_check_str(&var1)) {
       // Not a number or string.
       tv_clear(&var1);
       return FAIL;
@@ -4430,7 +4431,7 @@ eval_index (
           tv_clear(&var1);
         }
         return FAIL;
-      } else if (evaluate && get_tv_string_chk(&var2) == NULL) {
+      } else if (evaluate && !tv_check_str(&var2)) {
         // Not a number or string.
         if (!empty1) {
           tv_clear(&var1);
@@ -4566,7 +4567,7 @@ eval_index (
         }
 
         if (len == -1) {
-          key = get_tv_string_chk(&var1);
+          key = (char_u *)tv_get_string_chk(&var1);
           if (key == NULL) {
             tv_clear(&var1);
             return FAIL;
@@ -5570,7 +5571,7 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
   char_u      *key = NULL;
   dictitem_T  *item;
   char_u      *start = skipwhite(*arg + 1);
-  char_u buf[NUMBUFLEN];
+  char buf[NUMBUFLEN];
 
   /*
    * First check if it's not a curly-braces thing: {expr}.
@@ -5602,9 +5603,9 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
       goto failret;
     }
     if (evaluate) {
-      key = get_tv_string_buf_chk(&tvkey, buf);
+      key = (char_u *)tv_get_string_buf_chk(&tvkey, buf);
       if (key == NULL) {
-        // "key" is NULL when get_tv_string_buf_chk() gave an errmsg
+        // "key" is NULL when tv_get_string_buf_chk() gave an errmsg
         tv_clear(&tvkey);
         goto failret;
       }
@@ -6598,7 +6599,6 @@ static void f_api_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   long lnum;
-  char_u      *line;
   list_T      *l = NULL;
   listitem_T  *li = NULL;
   typval_T    *tv;
@@ -6622,21 +6622,23 @@ static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       li = l->lv_first;
     }
     for (;; ) {
-      if (l == NULL)
-        tv = &argvars[1];               /* append a string */
-      else if (li == NULL)
-        break;                          /* end of list */
-      else
-        tv = &li->li_tv;                /* append item from list */
-      line = get_tv_string_chk(tv);
-      if (line == NULL) {               /* type error */
-        rettv->vval.v_number = 1;               /* Failed */
+      if (l == NULL) {
+        tv = &argvars[1];  // Append a string.
+      } else if (li == NULL) {
+        break;  // End of list.
+      } else {
+        tv = &li->li_tv;  // Append item from list.
+      }
+      const char *const line = tv_get_string_chk(tv);
+      if (line == NULL) {  // Type error.
+        rettv->vval.v_number = 1;  // Failed.
         break;
       }
-      ml_append(lnum + added, line, (colnr_T)0, FALSE);
-      ++added;
-      if (l == NULL)
+      ml_append(lnum + added, (char_u *)line, (colnr_T)0, false);
+      added++;
+      if (l == NULL) {
         break;
+      }
       li = li->li_next;
     }
 
@@ -6802,7 +6804,7 @@ static void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   garray_T ga;
 
-  char *error = (char *)get_tv_string_chk(&argvars[0]);
+  const char *const error = tv_get_string_chk(&argvars[0]);
   if (vimvars[VV_EXCEPTION].vv_str == NULL) {
     prepare_assert_error(&ga);
     ga_concat(&ga, (char_u *)"v:exception is not set");
@@ -6821,22 +6823,22 @@ static void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "assert_fails(cmd [, error])" function
 static void f_assert_fails(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *cmd = get_tv_string_chk(&argvars[0]);
+  const char *const cmd = tv_get_string_chk(&argvars[0]);
   garray_T    ga;
 
   called_emsg = false;
   suppress_errthrow = true;
   emsg_silent = true;
-  do_cmdline_cmd((char *)cmd);
+  do_cmdline_cmd(cmd);
   if (!called_emsg) {
     prepare_assert_error(&ga);
-    ga_concat(&ga, (char_u *)"command did not fail: ");
-    ga_concat(&ga, cmd);
+    ga_concat(&ga, (const char_u *)"command did not fail: ");
+    ga_concat(&ga, (const char_u *)cmd);
     assert_error(&ga);
     ga_clear(&ga);
   } else if (argvars[1].v_type != VAR_UNKNOWN) {
-    char_u buf[NUMBUFLEN];
-    char *error = (char *)get_tv_string_buf_chk(&argvars[1], buf);
+    char buf[NUMBUFLEN];
+    const char *const error = tv_get_string_buf_chk(&argvars[1], buf);
 
     if (error == NULL
         || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL) {
@@ -6911,14 +6913,15 @@ static void f_assert_false(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void assert_match_common(typval_T *argvars, assert_type_T atype)
 {
-  char_u buf1[NUMBUFLEN];
-  char_u buf2[NUMBUFLEN];
-  char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1);
-  char_u *text = get_tv_string_buf_chk(&argvars[1], buf2);
+  char buf1[NUMBUFLEN];
+  char buf2[NUMBUFLEN];
+  const char *const pat = tv_get_string_buf_chk(&argvars[0], buf1);
+  const char *const text = tv_get_string_buf_chk(&argvars[1], buf2);
 
   if (pat == NULL || text == NULL) {
     EMSG(_(e_invarg));
-  } else if (pattern_match(pat, text, false) != (atype == ASSERT_MATCH)) {
+  } else if (pattern_match((char_u *)pat, (char_u *)text, false)
+             != (atype == ASSERT_MATCH)) {
     garray_T ga;
     prepare_assert_error(&ga);
     fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1], atype);
@@ -7107,7 +7110,6 @@ static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   bool error = false;
-  char_u *name;
 
   rettv->vval.v_number = -1;
   if (!tv_check_str_or_nr(&argvars[0])) {
@@ -7119,13 +7121,14 @@ static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   // If the buffer isn't found and the second argument is not zero create a
   // new buffer.
+  const char *name;
   if (buf == NULL
       && argvars[1].v_type != VAR_UNKNOWN
       && tv_get_number_chk(&argvars[1], &error) != 0
       && !error
-      && (name = get_tv_string_chk(&argvars[0])) != NULL
+      && (name = tv_get_string_chk(&argvars[0])) != NULL
       && !error) {
-    buf = buflist_new(name, NULL, (linenr_T)1, 0);
+    buf = buflist_new((char_u *)name, NULL, 1, 0);
   }
 
   if (buf != NULL) {
@@ -7190,24 +7193,23 @@ static void f_byte2line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void byteidx(typval_T *argvars, typval_T *rettv, int comp)
 {
-  char_u      *t;
-  char_u      *str;
-  long idx;
-
-  str = get_tv_string_chk(&argvars[0]);
-  idx = tv_get_number_chk(&argvars[1], NULL);
+  const char *const str = tv_get_string_chk(&argvars[0]);
+  varnumber_T idx = tv_get_number_chk(&argvars[1], NULL);
   rettv->vval.v_number = -1;
-  if (str == NULL || idx < 0)
+  if (str == NULL || idx < 0) {
     return;
+  }
 
-  t = str;
+  const char *t = str;
   for (; idx > 0; idx--) {
-    if (*t == NUL)              /* EOL reached */
+    if (*t == NUL) {  // EOL reached.
       return;
-    if (enc_utf8 && comp)
-      t += utf_ptr2len(t);
-    else
-      t += (*mb_ptr2len)(t);
+    }
+    if (enc_utf8 && comp) {
+      t += utf_ptr2len((const char_u *)t);
+    } else {
+      t += (*mb_ptr2len)((const char_u *)t);
+    }
   }
   rettv->vval.v_number = (varnumber_T)(t - str);
 }
@@ -7444,47 +7446,51 @@ static void f_complete_check(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_confirm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *message;
-  char_u      *buttons = NULL;
-  char_u buf[NUMBUFLEN];
-  char_u buf2[NUMBUFLEN];
+  char buf[NUMBUFLEN];
+  char buf2[NUMBUFLEN];
+  const char *message;
+  const char *buttons = NULL;
   int def = 1;
   int type = VIM_GENERIC;
-  char_u *typestr;
+  const char *typestr;
   bool error = false;
 
-  message = get_tv_string_chk(&argvars[0]);
-  if (message == NULL)
-    error = TRUE;
+  message = tv_get_string_chk(&argvars[0]);
+  if (message == NULL) {
+    error = true;
+  }
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    buttons = get_tv_string_buf_chk(&argvars[1], buf);
-    if (buttons == NULL)
-      error = TRUE;
+    buttons = tv_get_string_buf_chk(&argvars[1], buf);
+    if (buttons == NULL) {
+      error = true;
+    }
     if (argvars[2].v_type != VAR_UNKNOWN) {
       def = tv_get_number_chk(&argvars[2], &error);
       if (argvars[3].v_type != VAR_UNKNOWN) {
-        typestr = get_tv_string_buf_chk(&argvars[3], buf2);
-        if (typestr == NULL)
-          error = TRUE;
-        else {
+        typestr = tv_get_string_buf_chk(&argvars[3], buf2);
+        if (typestr == NULL) {
+          error = true;
+        } else {
           switch (TOUPPER_ASC(*typestr)) {
-          case 'E': type = VIM_ERROR; break;
-          case 'Q': type = VIM_QUESTION; break;
-          case 'I': type = VIM_INFO; break;
-          case 'W': type = VIM_WARNING; break;
-          case 'G': type = VIM_GENERIC; break;
+            case 'E': type = VIM_ERROR; break;
+            case 'Q': type = VIM_QUESTION; break;
+            case 'I': type = VIM_INFO; break;
+            case 'W': type = VIM_WARNING; break;
+            case 'G': type = VIM_GENERIC; break;
           }
         }
       }
     }
   }
 
-  if (buttons == NULL || *buttons == NUL)
-    buttons = (char_u *)_("&Ok");
+  if (buttons == NULL || *buttons == NUL) {
+    buttons = _("&Ok");
+  }
 
-  if (!error)
-    rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
-        def, NULL, FALSE);
+  if (!error) {
+    rettv->vval.v_number = do_dialog(
+        type, NULL, (char_u *)message, (char_u *)buttons, def, NULL, false);
+  }
 }
 
 /*
@@ -7708,32 +7714,29 @@ static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   if (argvars[0].v_type != VAR_DICT) {
-    EMSG2(e_invarg2, "dict");
+    emsgf(_(e_invarg2), "dict");
     return;
   }
 
   if (argvars[1].v_type != VAR_STRING && argvars[1].v_type != VAR_NUMBER) {
-    EMSG2(e_invarg2, "key");
+    emsgf(_(e_invarg2), "key");
     return;
   }
 
-  char *key_pattern = (char *)get_tv_string_chk(argvars + 1);
-  assert(key_pattern);
-  const size_t key_len = STRLEN(argvars[1].vval.v_string);
-
-  if (key_len == 0) {
-    EMSG(_(e_emptykey));
+  const char *const key_pattern = tv_get_string_chk(argvars + 1);
+  if (key_pattern == NULL) {
     return;
   }
+  const size_t key_pattern_len = strlen(key_pattern);
 
   Callback callback;
   if (!callback_from_typval(&callback, &argvars[2])) {
-    EMSG2(e_invarg2, "funcref");
+    emsgf(_(e_invarg2), "funcref");
     return;
   }
 
   DictWatcher *watcher = xmalloc(sizeof(DictWatcher));
-  watcher->key_pattern = xmemdupz(key_pattern, key_len);
+  watcher->key_pattern = xmemdupz(key_pattern, key_pattern_len);
   watcher->callback = callback;
   watcher->busy = false;
   QUEUE_INSERT_TAIL(&argvars[0].vval.v_dict->watchers, &watcher->node);
@@ -7747,26 +7750,17 @@ static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   if (argvars[0].v_type != VAR_DICT) {
-    EMSG2(e_invarg2, "dict");
-    return;
-  }
-
-  if (argvars[1].v_type != VAR_STRING && argvars[1].v_type != VAR_NUMBER) {
-    EMSG2(e_invarg2, "key");
+    emsgf(_(e_invarg2), "dict");
     return;
   }
 
   if (argvars[2].v_type != VAR_FUNC && argvars[2].v_type != VAR_STRING) {
-    EMSG2(e_invarg2, "funcref");
+    emsgf(_(e_invarg2), "funcref");
     return;
   }
 
-  char *key_pattern = (char *)get_tv_string_chk(argvars + 1);
-  assert(key_pattern);
-  const size_t key_len = STRLEN(argvars[1].vval.v_string);
-
-  if (key_len == 0) {
-    EMSG(_(e_emptykey));
+  const char *const key_pattern = tv_get_string_chk(argvars + 1);
+  if (key_pattern == NULL) {
     return;
   }
 
@@ -7924,16 +7918,15 @@ static void f_escape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_eval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *s;
-
-  s = get_tv_string_chk(&argvars[0]);
-  if (s != NULL)
-    s = skipwhite(s);
+  const char *s = tv_get_string_chk(&argvars[0]);
+  if (s != NULL) {
+    s = (const char *)skipwhite((const char_u *)s);
+  }
 
-  char_u *p = s;
-  if (s == NULL || eval1(&s, rettv, TRUE) == FAIL) {
-    if (p != NULL && !aborting()) {
-      EMSG2(_(e_invexpr2), p);
+  const char *const expr_start = s;
+  if (s == NULL || eval1((char_u **)&s, rettv, true) == FAIL) {
+    if (expr_start != NULL && !aborting()) {
+      EMSG2(_(e_invexpr2), expr_start);
     }
     need_clr_eos = FALSE;
     rettv->v_type = VAR_NUMBER;
@@ -7965,75 +7958,74 @@ static void f_executable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
           && os_can_exe((const char_u *)name, NULL, false)));
 }
 
-static char_u * get_list_line(int c, void *cookie, int indent)
+static char_u *get_list_line(int c, void *cookie, int indent)
 {
-  listitem_T **p = (listitem_T **)cookie;
-  listitem_T *item = *p;
-  char_u buf[NUMBUFLEN];
-  char_u *s;
+  const listitem_T **const p = (const listitem_T **)cookie;
+  const listitem_T *item = *p;
 
   if (item == NULL) {
     return NULL;
   }
-  s = get_tv_string_buf_chk(&item->li_tv, buf);
+  char buf[NUMBUFLEN];
+  const char *const s = tv_get_string_buf_chk(&item->li_tv, buf);
   *p = item->li_next;
-  return s == NULL ? NULL : vim_strsave(s);
+  return (char_u *)(s == NULL ? NULL : xstrdup(s));
 }
 
 // "execute(command)" function
 static void f_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-    int save_msg_silent = msg_silent;
-    int save_emsg_silent = emsg_silent;
-    bool save_emsg_noredir = emsg_noredir;
-    garray_T *save_capture_ga = capture_ga;
+  const int save_msg_silent = msg_silent;
+  const int save_emsg_silent = emsg_silent;
+  const bool save_emsg_noredir = emsg_noredir;
+  garray_T *const save_capture_ga = capture_ga;
 
-    if (check_secure()) {
-      return;
-    }
+  if (check_secure()) {
+    return;
+  }
 
-    if (argvars[1].v_type != VAR_UNKNOWN) {
-      char_u buf[NUMBUFLEN];
-      char_u *s = get_tv_string_buf_chk(&argvars[1], buf);
+  if (argvars[1].v_type != VAR_UNKNOWN) {
+    char buf[NUMBUFLEN];
+    const char *const s = tv_get_string_buf_chk(&argvars[1], buf);
 
-      if (s == NULL) {
-        return;
-      }
-      if (STRNCMP(s, "silent", 6) == 0) {
-        msg_silent++;
-      }
-      if (STRCMP(s, "silent!") == 0) {
-        emsg_silent = true;
-        emsg_noredir = true;
-      }
-    } else {
+    if (s == NULL) {
+      return;
+    }
+    if (strncmp(s, S_LEN("silent")) == 0) {
       msg_silent++;
     }
-
-    garray_T capture_local;
-    ga_init(&capture_local, (int)sizeof(char), 80);
-    capture_ga = &capture_local;
-
-    if (argvars[0].v_type != VAR_LIST) {
-      do_cmdline_cmd(tv_get_string(&argvars[0]));
-    } else if (argvars[0].vval.v_list != NULL) {
-      list_T *const list = argvars[0].vval.v_list;
-      list->lv_refcount++;
-      listitem_T *const item = list->lv_first;
-      do_cmdline(NULL, get_list_line, (void *)&item,
-                 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
-      list->lv_refcount--;
+    if (strcmp(s, "silent!") == 0) {
+      emsg_silent = true;
+      emsg_noredir = true;
     }
-    msg_silent = save_msg_silent;
-    emsg_silent = save_emsg_silent;
-    emsg_noredir = save_emsg_noredir;
+  } else {
+    msg_silent++;
+  }
 
-    ga_append(capture_ga, NUL);
-    rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = vim_strsave(capture_ga->ga_data);
-    ga_clear(capture_ga);
+  garray_T capture_local;
+  ga_init(&capture_local, (int)sizeof(char), 80);
+  capture_ga = &capture_local;
 
-    capture_ga = save_capture_ga;
+  if (argvars[0].v_type != VAR_LIST) {
+    do_cmdline_cmd(tv_get_string(&argvars[0]));
+  } else if (argvars[0].vval.v_list != NULL) {
+    list_T *const list = argvars[0].vval.v_list;
+    list->lv_refcount++;
+    listitem_T *const item = list->lv_first;
+    do_cmdline(NULL, get_list_line, (void *)&item,
+               DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
+    list->lv_refcount--;
+  }
+  msg_silent = save_msg_silent;
+  emsg_silent = save_emsg_silent;
+  emsg_noredir = save_emsg_noredir;
+
+  ga_append(capture_ga, NUL);
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = vim_strsave(capture_ga->ga_data);
+  ga_clear(capture_ga);
+
+  capture_ga = save_capture_ga;
 }
 
 /// "exepath()" function
@@ -8231,7 +8223,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       if (argvars[2].v_type != VAR_UNKNOWN) {
         const char *const av[] = { "keep", "force", "error" };
 
-        action = (const char *)get_tv_string_chk(&argvars[2]);
+        action = tv_get_string_chk(&argvars[2]);
         if (action == NULL) {
           return;  // Type error; error message already given.
         }
@@ -8300,10 +8292,8 @@ static void f_filewritable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 {
-  char_u      *fresult = NULL;
-  char_u      *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
-  char_u      *p;
-  char_u pathbuf[NUMBUFLEN];
+  char_u *fresult = NULL;
+  char_u *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
   int count = 1;
   bool first = true;
   bool error = false;
@@ -8313,13 +8303,15 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 
   const char *fname = tv_get_string(&argvars[0]);
 
+  char pathbuf[NUMBUFLEN];
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    p = get_tv_string_buf_chk(&argvars[1], pathbuf);
-    if (p == NULL)
-      error = TRUE;
-    else {
-      if (*p != NUL)
-        path = p;
+    const char *p = tv_get_string_buf_chk(&argvars[1], pathbuf);
+    if (p == NULL) {
+      error = true;
+    } else {
+      if (*p != NUL) {
+        path = (char_u *)p;
+      }
 
       if (argvars[2].v_type != VAR_UNKNOWN) {
         count = tv_get_number_chk(&argvars[2], &error);
@@ -8473,8 +8465,6 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
 {
   typval_T rettv;
   typval_T argv[3];
-  char_u buf[NUMBUFLEN];
-  char_u      *s;
   int retval = FAIL;
   int dummy;
 
@@ -8482,7 +8472,7 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
   argv[0] = vimvars[VV_KEY].vv_tv;
   argv[1] = vimvars[VV_VAL].vv_tv;
   if (expr->v_type == VAR_FUNC) {
-    s = expr->vval.v_string;
+    const char_u *const s = expr->vval.v_string;
     if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
                   0L, 0L, &dummy, true, NULL, NULL) == FAIL) {
       goto theend;
@@ -8490,23 +8480,24 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
   } else if (expr->v_type == VAR_PARTIAL) {
     partial_T *partial = expr->vval.v_partial;
 
-    s = partial_name(partial);
+    const char_u *const s = partial_name(partial);
     if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
                   0L, 0L, &dummy, true, partial, NULL) == FAIL) {
       goto theend;
     }
   } else {
-    s = get_tv_string_buf_chk(expr, buf);
+    char buf[NUMBUFLEN];
+    const char *s = tv_get_string_buf_chk(expr, buf);
     if (s == NULL) {
       goto theend;
     }
-    s = skipwhite(s);
-    if (eval1(&s, &rettv, true) == FAIL) {
+    s = (const char *)skipwhite((const char_u *)s);
+    if (eval1((char_u **)&s, &rettv, true) == FAIL) {
       goto theend;
     }
 
     if (*s != NUL) {  // check for trailing chars after expr
-      EMSG2(_(e_invexpr2), s);
+      emsgf(_(e_invexpr2), s);
       goto theend;
     }
   }
@@ -8606,27 +8597,26 @@ static void f_fnameescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_fnamemodify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *fname;
-  char_u      *mods;
-  size_t usedlen = 0;
+  char_u *fbuf = NULL;
   size_t len;
-  char_u      *fbuf = NULL;
-  char_u buf[NUMBUFLEN];
-
-  fname = get_tv_string_chk(&argvars[0]);
-  mods = get_tv_string_buf_chk(&argvars[1], buf);
-  if (fname == NULL || mods == NULL)
+  char buf[NUMBUFLEN];
+  const char *fname = tv_get_string_chk(&argvars[0]);
+  const char *const mods = tv_get_string_buf_chk(&argvars[1], buf);
+  if (fname == NULL || mods == NULL) {
     fname = NULL;
-  else {
-    len = STRLEN(fname);
-    (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len);
+  } else {
+    len = strlen(fname);
+    size_t usedlen = 0;
+    (void)modify_fname((char_u *)mods, &usedlen, (char_u **)&fname, &fbuf,
+                       &len);
   }
 
   rettv->v_type = VAR_STRING;
-  if (fname == NULL)
+  if (fname == NULL) {
     rettv->vval.v_string = NULL;
-  else
-    rettv->vval.v_string = vim_strnsave(fname, len);
+  } else {
+    rettv->vval.v_string = (char_u *)xmemdupz(fname, len);
+  }
   xfree(fbuf);
 }
 
@@ -9257,7 +9247,7 @@ static void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     goto f_getbufvar_end;
   }
 
-  const char *varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *varname = tv_get_string_chk(&argvars[1]);
   emsg_off++;
   buf_T *const buf = get_buf_tv(&argvars[0], false);
 
@@ -9970,14 +9960,13 @@ static void f_getqflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "getreg()" function
 static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *strregname;
-  int regname;
+  const char *strregname;
   int arg2 = false;
   bool return_list = false;
   bool error = false;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
-    strregname = get_tv_string_chk(&argvars[0]);
+    strregname = tv_get_string_chk(&argvars[0]);
     error = strregname == NULL;
     if (argvars[1].v_type != VAR_UNKNOWN) {
       arg2 = tv_get_number_chk(&argvars[1], &error);
@@ -9986,16 +9975,17 @@ static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       }
     }
   } else {
-    strregname = vimvars[VV_REG].vv_str;
+    strregname = (const char *)vimvars[VV_REG].vv_str;
   }
 
   if (error) {
     return;
   }
 
-  regname = (strregname == NULL ? '"' : *strregname);
-  if (regname == 0)
+  int regname = (uint8_t)(strregname == NULL ? '"' : *strregname);
+  if (regname == 0) {
     regname = '"';
+  }
 
   if (return_list) {
     rettv->v_type = VAR_LIST;
@@ -10016,23 +10006,24 @@ static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getregtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *strregname;
-  int regname;
+  const char *strregname;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
-    strregname = get_tv_string_chk(&argvars[0]);
-    if (strregname == NULL) {       /* type error; errmsg already given */
+    strregname = tv_get_string_chk(&argvars[0]);
+    if (strregname == NULL) {  // Type error; errmsg already given.
       rettv->v_type = VAR_STRING;
       rettv->vval.v_string = NULL;
       return;
     }
-  } else
-    /* Default to v:register */
-    strregname = vimvars[VV_REG].vv_str;
+  } else {
+    // Default to v:register.
+    strregname = (const char *)vimvars[VV_REG].vv_str;
+  }
 
-  regname = (strregname == NULL ? '"' : *strregname);
-  if (regname == 0)
+  int regname = (uint8_t)(strregname == NULL ? '"' : *strregname);
+  if (regname == 0) {
     regname = '"';
+  }
 
   colnr_T reglen = 0;
   char buf[NUMBUFLEN + 2];
@@ -10108,7 +10099,7 @@ static void f_gettabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
 
-  const char *const varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *const varname = tv_get_string_chk(&argvars[1]);
   tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
   if (tp != NULL && varname != NULL) {
     // Set tp to be our tabpage, temporarily.  Also set the window to the
@@ -10307,8 +10298,7 @@ getwinvar (
     tp = curtab;
   }
   win = find_win_by_nr(&argvars[off], tp);
-  const char *varname = (const char *)get_tv_string_chk(
-      &argvars[off + 1]);
+  const char *varname = tv_get_string_chk(&argvars[off + 1]);
 
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -10438,12 +10428,12 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   }
 
-  char_u buf1[NUMBUFLEN];
-  char_u *file = get_tv_string_buf_chk(&argvars[1], buf1);
+  char buf1[NUMBUFLEN];
+  const char *const file = tv_get_string_buf_chk(&argvars[1], buf1);
   if (file != NULL && !error) {
     garray_T ga;
     ga_init(&ga, (int)sizeof(char_u *), 10);
-    globpath((char_u *)tv_get_string(&argvars[0]), file, &ga, flags);
+    globpath((char_u *)tv_get_string(&argvars[0]), (char_u *)file, &ga, flags);
 
     if (rettv->v_type == VAR_STRING) {
       rettv->vval.v_string = ga_concat_strings_sep(&ga, "\n");
@@ -10464,12 +10454,13 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 // "glob2regpat()" function
 static void f_glob2regpat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *pat = get_tv_string_chk(&argvars[0]);  // NULL on type error
+  const char *const pat = tv_get_string_chk(&argvars[0]);  // NULL on type error
 
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (pat == NULL)
-    ? NULL
-    : file_pat_to_reg_pat(pat, NULL, NULL, false);
+  rettv->vval.v_string = ((pat == NULL)
+                          ? NULL
+                          : file_pat_to_reg_pat((char_u *)pat, NULL, NULL,
+                                                false));
 }
 
 /// "has()" function
@@ -10797,14 +10788,14 @@ static void f_histadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (check_restricted() || check_secure()) {
     return;
   }
-  char_u *str = get_tv_string_chk(&argvars[0]);  // NULL on type error
-  histype = str != NULL ? get_histtype(str, STRLEN(str), false) : HIST_INVALID;
+  const char *str = tv_get_string_chk(&argvars[0]);  // NULL on type error
+  histype = str != NULL ? get_histtype(str, strlen(str), false) : HIST_INVALID;
   if (histype != HIST_INVALID) {
     char buf[NUMBUFLEN];
-    str = (char_u *)tv_get_string_buf(&argvars[1], buf);
+    str = tv_get_string_buf(&argvars[1], buf);
     if (*str != NUL) {
       init_history();
-      add_to_history(histype, str, false, NUL);
+      add_to_history(histype, (char_u *)str, false, NUL);
       rettv->vval.v_number = true;
       return;
     }
@@ -10817,22 +10808,20 @@ static void f_histadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_histdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int n;
-  char_u      *str;
-
-  str = get_tv_string_chk(&argvars[0]);  // NULL on type error
+  const char *const str = tv_get_string_chk(&argvars[0]);  // NULL on type error
   if (str == NULL) {
     n = 0;
   } else if (argvars[1].v_type == VAR_UNKNOWN) {
     // only one argument: clear entire history
-    n = clr_history(get_histtype(str, STRLEN(str), false));
+    n = clr_history(get_histtype(str, strlen(str), false));
   } else if (argvars[1].v_type == VAR_NUMBER) {
     // index given: remove that entry
-    n = del_history_idx(get_histtype(str, STRLEN(str), false),
+    n = del_history_idx(get_histtype(str, strlen(str), false),
                         (int)tv_get_number(&argvars[1]));
   } else {
     // string given: remove all matching entries
     char buf[NUMBUFLEN];
-    n = del_history_entry(get_histtype(str, STRLEN(str), false),
+    n = del_history_entry(get_histtype(str, strlen(str), false),
                           (char_u *)tv_get_string_buf(&argvars[1], buf));
   }
   rettv->vval.v_number = n;
@@ -10845,13 +10834,12 @@ static void f_histget(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   HistoryType type;
   int idx;
-  char_u      *str;
 
-  str = get_tv_string_chk(&argvars[0]);  // NULL on type error
+  const char *const str = tv_get_string_chk(&argvars[0]);  // NULL on type error
   if (str == NULL) {
     rettv->vval.v_string = NULL;
   } else {
-    type = get_histtype(str, STRLEN(str), false);
+    type = get_histtype(str, strlen(str), false);
     if (argvars[1].v_type == VAR_UNKNOWN) {
       idx = get_history_idx(type);
     } else {
@@ -10870,9 +10858,9 @@ static void f_histnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int i;
 
-  char_u      *history = get_tv_string_chk(&argvars[0]);
+  const char *const history = tv_get_string_chk(&argvars[0]);
 
-  i = history == NULL ? HIST_CMD - 1 : get_histtype(history, STRLEN(history),
+  i = history == NULL ? HIST_CMD - 1 : get_histtype(history, strlen(history),
                                                     false);
   if (i != HIST_INVALID) {
     i = get_history_idx(i);
@@ -11009,11 +10997,8 @@ static int inputsecret_flag = 0;
  */
 static void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog)
 {
-  char_u      *prompt = get_tv_string_chk(&argvars[0]);
-  char_u      *p = NULL;
-  int c;
+  const char *prompt = tv_get_string_chk(&argvars[0]);
   int cmd_silent_save = cmd_silent;
-  char_u      *defstr = (char_u *)"";
   int xp_type = EXPAND_NOTHING;
   char_u      *xp_arg = NULL;
 
@@ -11022,49 +11007,45 @@ static void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog)
 
   cmd_silent = FALSE;           /* Want to see the prompt. */
   if (prompt != NULL) {
-    /* Only the part of the message after the last NL is considered as
-     * prompt for the command line */
-    p = vim_strrchr(prompt, '\n');
-    if (p == NULL)
+    // Only the part of the message after the last NL is considered as
+    // prompt for the command line.
+    const char *p = strrchr(prompt, '\n');
+    if (p == NULL) {
       p = prompt;
-    else {
-      ++p;
-      c = *p;
-      *p = NUL;
+    } else {
+      p++;
       msg_start();
       msg_clr_eos();
-      msg_puts_attr((const char *)prompt, echo_attr);
+      msg_puts_attr_len(prompt, p - prompt, echo_attr);
       msg_didout = false;
       msg_starthere();
-      *p = c;
     }
     cmdline_row = msg_row;
 
+    const char *defstr = "";
     if (argvars[1].v_type != VAR_UNKNOWN) {
-      char_u buf[NUMBUFLEN];
-      defstr = get_tv_string_buf_chk(&argvars[1], buf);
+      char buf[NUMBUFLEN];
+      defstr = tv_get_string_buf_chk(&argvars[1], buf);
       if (defstr != NULL) {
         stuffReadbuffSpec(defstr);
       }
 
       if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN) {
-        char_u  *xp_name;
-        int xp_namelen;
-        uint32_t argt;
-
-        /* input() with a third argument: completion */
+        // input() with a third argument: completion
         rettv->vval.v_string = NULL;
 
-        xp_name = get_tv_string_buf_chk(&argvars[2], buf);
+        const char *const xp_name = tv_get_string_buf_chk(&argvars[2], buf);
         if (xp_name == NULL) {
           return;
         }
 
-        xp_namelen = (int)STRLEN(xp_name);
+        const int xp_namelen = (int)strlen(xp_name);
 
-        if (parse_compl_arg(xp_name, xp_namelen, &xp_type, &argt,
-                &xp_arg) == FAIL)
+        uint32_t argt;
+        if (parse_compl_arg((char_u *)xp_name, xp_namelen, &xp_type, &argt,
+                            &xp_arg) == FAIL) {
           return;
+        }
       }
     }
 
@@ -11072,8 +11053,8 @@ static void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog)
       int save_ex_normal_busy = ex_normal_busy;
       ex_normal_busy = 0;
       rettv->vval.v_string =
-        getcmdline_prompt(inputsecret_flag ? NUL : '@', p, echo_attr,
-            xp_type, xp_arg);
+        getcmdline_prompt(inputsecret_flag ? NUL : '@', (char_u *)p, echo_attr,
+                          xp_type, xp_arg);
       ex_normal_busy = save_ex_normal_busy;
     }
     if (inputdialog && rettv->vval.v_string == NULL
@@ -11544,8 +11525,8 @@ static char **tv_to_argv(typval_T *cmd_tv, const char **cmd, bool *executable)
 
   assert(argl->lv_first);
 
-  const char_u *exe = get_tv_string_chk(&argl->lv_first->li_tv);
-  if (!exe || !os_can_exe(exe, NULL, true)) {
+  const char *exe = tv_get_string_chk(&argl->lv_first->li_tv);
+  if (!exe || !os_can_exe((const char_u *)exe, NULL, true)) {
     if (exe && executable) {
       *executable = false;
     }
@@ -11553,14 +11534,14 @@ static char **tv_to_argv(typval_T *cmd_tv, const char **cmd, bool *executable)
   }
 
   if (cmd) {
-    *cmd = (char *)exe;
+    *cmd = exe;
   }
 
   // Build the argument vector
   int i = 0;
   char **argv = xcalloc(argc + 1, sizeof(char *));
   for (listitem_T *arg = argl->lv_first; arg != NULL; arg = arg->li_next) {
-    char *a = (char *)get_tv_string_chk(&arg->li_tv);
+    const char *a = tv_get_string_chk(&arg->li_tv);
     if (!a) {
       // Did emsg in tv_get_string_chk; just deallocate argv.
       shell_free_argv(argv);
@@ -11803,50 +11784,49 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_join(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  garray_T ga;
-  char_u      *sep;
-
   if (argvars[0].v_type != VAR_LIST) {
     EMSG(_(e_listreq));
     return;
   }
-  if (argvars[0].vval.v_list == NULL)
+  if (argvars[0].vval.v_list == NULL) {
     return;
-  if (argvars[1].v_type == VAR_UNKNOWN)
-    sep = (char_u *)" ";
-  else
-    sep = get_tv_string_chk(&argvars[1]);
+  }
+  const char *const sep = (argvars[1].v_type == VAR_UNKNOWN
+                           ? " "
+                           : tv_get_string_chk(&argvars[1]));
 
   rettv->v_type = VAR_STRING;
 
   if (sep != NULL) {
+    garray_T ga;
     ga_init(&ga, (int)sizeof(char), 80);
-    tv_list_join(&ga, argvars[0].vval.v_list, (const char *)sep);
+    tv_list_join(&ga, argvars[0].vval.v_list, sep);
     ga_append(&ga, NUL);
     rettv->vval.v_string = (char_u *)ga.ga_data;
-  } else
+  } else {
     rettv->vval.v_string = NULL;
+  }
 }
 
 /// json_decode() function
 static void f_json_decode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   char numbuf[NUMBUFLEN];
-  char *s = NULL;
+  const char *s = NULL;
   char *tofree = NULL;
   size_t len;
   if (argvars[0].v_type == VAR_LIST) {
-    if (!encode_vim_list_to_buf(argvars[0].vval.v_list, &len, &s)) {
+    if (!encode_vim_list_to_buf(argvars[0].vval.v_list, &len, &tofree)) {
       EMSG(_("E474: Failed to convert list to string"));
       return;
     }
-    tofree = s;
+    s = tofree;
     if (s == NULL) {
       assert(len == 0);
       s = "";
     }
   } else {
-    s = (char *) get_tv_string_buf_chk(&argvars[0], (char_u *) numbuf);
+    s = tv_get_string_buf_chk(&argvars[0], numbuf);
     if (s) {
       len = strlen(s);
     } else {
@@ -12043,10 +12023,8 @@ static void f_localtime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
 {
-  char_u      *which;
-  char_u buf[NUMBUFLEN];
-  char_u      *keys_buf = NULL;
-  char_u      *rhs;
+  char_u *keys_buf = NULL;
+  char_u *rhs;
   int mode;
   int abbr = FALSE;
   int get_dict = FALSE;
@@ -12062,20 +12040,24 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     return;
   }
 
+  char buf[NUMBUFLEN];
+  const char *which;
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    which = get_tv_string_buf_chk(&argvars[1], buf);
+    which = tv_get_string_buf_chk(&argvars[1], buf);
     if (argvars[2].v_type != VAR_UNKNOWN) {
       abbr = tv_get_number(&argvars[2]);
       if (argvars[3].v_type != VAR_UNKNOWN) {
         get_dict = tv_get_number(&argvars[3]);
       }
     }
-  } else
-    which = (char_u *)"";
-  if (which == NULL)
+  } else {
+    which = "";
+  }
+  if (which == NULL) {
     return;
+  }
 
-  mode = get_map_mode(&which, 0);
+  mode = get_map_mode((char_u **)&which, 0);
 
   keys = replace_termcodes(keys, STRLEN(keys), &keys_buf, true, true, false,
                            CPO_TO_CPO_FLAGS);
@@ -12141,9 +12123,7 @@ static void find_some_match(typval_T *argvars, typval_T *rettv, int type)
   char_u      *str = NULL;
   long        len = 0;
   char_u      *expr = NULL;
-  char_u      *pat;
   regmatch_T regmatch;
-  char_u patbuf[NUMBUFLEN];
   char_u      *save_cpo;
   long start = 0;
   long nth = 1;
@@ -12183,9 +12163,11 @@ static void find_some_match(typval_T *argvars, typval_T *rettv, int type)
     len = (long)STRLEN(str);
   }
 
-  pat = get_tv_string_buf_chk(&argvars[1], patbuf);
-  if (pat == NULL)
+  char patbuf[NUMBUFLEN];
+  const char *const pat = tv_get_string_buf_chk(&argvars[1], patbuf);
+  if (pat == NULL) {
     goto theend;
+  }
 
   if (argvars[2].v_type != VAR_UNKNOWN) {
     bool error = false;
@@ -12224,7 +12206,7 @@ static void find_some_match(typval_T *argvars, typval_T *rettv, int type)
     }
   }
 
-  regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
+  regmatch.regprog = vim_regcomp((char_u *)pat, RE_MAGIC + RE_STRING);
   if (regmatch.regprog != NULL) {
     regmatch.rm_ic = p_ic;
 
@@ -12336,18 +12318,20 @@ static void f_match(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u buf[NUMBUFLEN];
-  char_u      *grp = get_tv_string_buf_chk(&argvars[0], buf);   /* group */
-  char_u      *pat = get_tv_string_buf_chk(&argvars[1], buf);   /* pattern */
-  int prio = 10;                /* default priority */
+  char grpbuf[NUMBUFLEN];
+  char patbuf[NUMBUFLEN];
+  const char *const grp = tv_get_string_buf_chk(&argvars[0], grpbuf);
+  const char *const pat = tv_get_string_buf_chk(&argvars[1], patbuf);
+  int prio = 10;
   int id = -1;
   bool error = false;
   const char *conceal_char = NULL;
 
   rettv->vval.v_number = -1;
 
-  if (grp == NULL || pat == NULL)
+  if (grp == NULL || pat == NULL) {
     return;
+  }
   if (argvars[2].v_type != VAR_UNKNOWN) {
     prio = tv_get_number_chk(&argvars[2], &error);
     if (argvars[3].v_type != VAR_UNKNOWN) {
@@ -12365,7 +12349,7 @@ static void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       }
     }
   }
-  if (error == true) {
+  if (error) {
     return;
   }
   if (id >= 1 && id <= 3) {
@@ -12373,17 +12357,16 @@ static void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     return;
   }
 
-  rettv->vval.v_number = match_add(curwin, (const char *)grp,
-                                   (const char *)pat, prio, id,
-                                   NULL, conceal_char);
+  rettv->vval.v_number = match_add(curwin, grp, pat, prio, id, NULL,
+                                   conceal_char);
 }
 
 static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
     rettv->vval.v_number = -1;
-    
-    char_u buf[NUMBUFLEN];
-    const char_u *const group = get_tv_string_buf_chk(&argvars[0], buf);
+
+    char buf[NUMBUFLEN];
+    const char *const group = tv_get_string_buf_chk(&argvars[0], buf);
     if (group == NULL) {
         return;
     }
@@ -12431,8 +12414,8 @@ static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         return;
     }
 
-  rettv->vval.v_number = match_add(curwin, (const char *)group, NULL, prio, id,
-                                   l, conceal_char);
+  rettv->vval.v_number = match_add(curwin, group, NULL, prio, id, l,
+                                   conceal_char);
 }
 
 /*
@@ -12833,11 +12816,11 @@ static void f_or(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_pathshorten(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = get_tv_string_chk(&argvars[0]);
-  if (!rettv->vval.v_string) {
+  const char *const s = tv_get_string_chk(&argvars[0]);
+  if (!s) {
     return;
   }
-  rettv->vval.v_string = shorten_dir(vim_strsave(rettv->vval.v_string));
+  rettv->vval.v_string = shorten_dir((char_u *)xstrdup(s));
 }
 
 /*
@@ -13240,7 +13223,7 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       EMSG2(_(e_toomanyarg), "remove()");
     } else if ((d = argvars[0].vval.v_dict) != NULL
                && !tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len)) {
-      const char *key = (const char *)get_tv_string_chk(&argvars[1]);
+      const char *key = tv_get_string_chk(&argvars[1]);
       if (key != NULL) {
         di = tv_dict_find(d, key, -1);
         if (di == NULL) {
@@ -13572,40 +13555,45 @@ static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static int get_search_arg(typval_T *varp, int *flagsp)
 {
   int dir = FORWARD;
-  char_u      *flags;
-  char_u nbuf[NUMBUFLEN];
   int mask;
 
   if (varp->v_type != VAR_UNKNOWN) {
-    flags = get_tv_string_buf_chk(varp, nbuf);
-    if (flags == NULL)
-      return 0;                 /* type error; errmsg already given */
+    char nbuf[NUMBUFLEN];
+    const char *flags = tv_get_string_buf_chk(varp, nbuf);
+    if (flags == NULL) {
+      return 0;  // Type error; errmsg already given.
+    }
     while (*flags != NUL) {
       switch (*flags) {
-      case 'b': dir = BACKWARD; break;
-      case 'w': p_ws = true; break;
-      case 'W': p_ws = false; break;
-      default:  mask = 0;
-        if (flagsp != NULL)
-          switch (*flags) {
-            case 'c': mask = SP_START; break;
-            case 'e': mask = SP_END; break;
-            case 'm': mask = SP_RETCOUNT; break;
-            case 'n': mask = SP_NOMOVE; break;
-            case 'p': mask = SP_SUBPAT; break;
-            case 'r': mask = SP_REPEAT; break;
-            case 's': mask = SP_SETPCMARK; break;
-            case 'z': mask = SP_COLUMN; break;
+        case 'b': dir = BACKWARD; break;
+        case 'w': p_ws = true; break;
+        case 'W': p_ws = false; break;
+        default: {
+          mask = 0;
+          if (flagsp != NULL) {
+            switch (*flags) {
+              case 'c': mask = SP_START; break;
+              case 'e': mask = SP_END; break;
+              case 'm': mask = SP_RETCOUNT; break;
+              case 'n': mask = SP_NOMOVE; break;
+              case 'p': mask = SP_SUBPAT; break;
+              case 'r': mask = SP_REPEAT; break;
+              case 's': mask = SP_SETPCMARK; break;
+              case 'z': mask = SP_COLUMN; break;
+            }
           }
-        if (mask == 0) {
-          EMSG2(_(e_invarg2), flags);
-          dir = 0;
-        } else
-          *flagsp |= mask;
+          if (mask == 0) {
+            emsgf(_(e_invarg2), flags);
+            dir = 0;
+          } else {
+            *flagsp |= mask;
+          }
+        }
       }
-      if (dir == 0)
+      if (dir == 0) {
         break;
-      ++flags;
+      }
+      flags++;
     }
   }
   return dir;
@@ -13989,16 +13977,17 @@ static void f_searchdecl(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   rettv->vval.v_number = 1;     /* default: FAIL */
 
-  char_u *name = get_tv_string_chk(&argvars[0]);
+  const char *const name = tv_get_string_chk(&argvars[0]);
   if (argvars[1].v_type != VAR_UNKNOWN) {
     locally = tv_get_number_chk(&argvars[1], &error) == 0;
     if (!error && argvars[2].v_type != VAR_UNKNOWN) {
       thisblock = tv_get_number_chk(&argvars[2], &error) != 0;
     }
   }
-  if (!error && name != NULL)
-    rettv->vval.v_number = find_decl(name, STRLEN(name), locally,
+  if (!error && name != NULL) {
+    rettv->vval.v_number = find_decl((char_u *)name, strlen(name), locally,
                                      thisblock, SEARCH_KEEP) == FAIL;
+  }
 }
 
 /*
@@ -14006,49 +13995,53 @@ static void f_searchdecl(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static int searchpair_cmn(typval_T *argvars, pos_T *match_pos)
 {
-  char_u      *spat, *mpat, *epat;
-  char_u      *skip;
   bool save_p_ws = p_ws;
   int dir;
   int flags = 0;
-  char_u nbuf1[NUMBUFLEN];
-  char_u nbuf2[NUMBUFLEN];
-  char_u nbuf3[NUMBUFLEN];
-  int retval = 0;                       /* default: FAIL */
+  int retval = 0;  // default: FAIL
   long lnum_stop = 0;
   long time_limit = 0;
 
-  /* Get the three pattern arguments: start, middle, end. */
-  spat = get_tv_string_chk(&argvars[0]);
-  mpat = get_tv_string_buf_chk(&argvars[1], nbuf1);
-  epat = get_tv_string_buf_chk(&argvars[2], nbuf2);
-  if (spat == NULL || mpat == NULL || epat == NULL)
-    goto theend;            /* type error */
+  // Get the three pattern arguments: start, middle, end.
+  char nbuf1[NUMBUFLEN];
+  char nbuf2[NUMBUFLEN];
+  char nbuf3[NUMBUFLEN];
+  const char *spat = tv_get_string_chk(&argvars[0]);
+  const char *mpat = tv_get_string_buf_chk(&argvars[1], nbuf1);
+  const char *epat = tv_get_string_buf_chk(&argvars[2], nbuf2);
+  if (spat == NULL || mpat == NULL || epat == NULL) {
+    goto theend;  // Type error.
+  }
 
-  /* Handle the optional fourth argument: flags */
-  dir = get_search_arg(&argvars[3], &flags);   /* may set p_ws */
-  if (dir == 0)
+  // Handle the optional fourth argument: flags.
+  dir = get_search_arg(&argvars[3], &flags);   // may set p_ws.
+  if (dir == 0) {
     goto theend;
+  }
 
-  /* Don't accept SP_END or SP_SUBPAT.
-   * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
-   */
+  // Don't accept SP_END or SP_SUBPAT.
+  // Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
   if ((flags & (SP_END | SP_SUBPAT)) != 0
       || ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK))) {
     EMSG2(_(e_invarg2), tv_get_string(&argvars[3]));
     goto theend;
   }
 
-  /* Using 'r' implies 'W', otherwise it doesn't work. */
-  if (flags & SP_REPEAT)
+  // Using 'r' implies 'W', otherwise it doesn't work.
+  if (flags & SP_REPEAT) {
     p_ws = false;
+  }
 
-  /* Optional fifth argument: skip expression */
+  // Optional fifth argument: skip expression.
+  const char *skip;
   if (argvars[3].v_type == VAR_UNKNOWN
-      || argvars[4].v_type == VAR_UNKNOWN)
-    skip = (char_u *)"";
-  else {
-    skip = get_tv_string_buf_chk(&argvars[4], nbuf3);
+      || argvars[4].v_type == VAR_UNKNOWN) {
+    skip = "";
+  } else {
+    skip = tv_get_string_buf_chk(&argvars[4], nbuf3);
+    if (skip == NULL) {
+      goto theend;  // Type error.
+    }
     if (argvars[5].v_type != VAR_UNKNOWN) {
       lnum_stop = tv_get_number_chk(&argvars[5], NULL);
       if (lnum_stop < 0) {
@@ -14062,11 +14055,10 @@ static int searchpair_cmn(typval_T *argvars, pos_T *match_pos)
       }
     }
   }
-  if (skip == NULL)
-    goto theend;            /* type error */
 
-  retval = do_searchpair(spat, mpat, epat, dir, skip, flags,
-      match_pos, lnum_stop, time_limit);
+  retval = do_searchpair(
+      (char_u *)spat, (char_u *)mpat, (char_u *)epat, dir, (char_u *)skip,
+      flags, match_pos, lnum_stop, time_limit);
 
 theend:
   p_ws = save_p_ws;
@@ -14341,14 +14333,12 @@ static void f_serverstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u nbuf[NUMBUFLEN];
-
   if (check_restricted()
       || check_secure()
       || !tv_check_str_or_nr(&argvars[0])) {
     return;
   }
-  const char *varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *varname = tv_get_string_chk(&argvars[1]);
   buf_T *const buf = get_buf_tv(&argvars[0], false);
   typval_T *varp = &argvars[2];
 
@@ -14363,7 +14353,8 @@ static void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
       varname++;
       numval = tv_get_number_chk(varp, &error);
-      char *const strval = (char *)get_tv_string_buf_chk(varp, nbuf);
+      char nbuf[NUMBUFLEN];
+      const char *const strval = tv_get_string_buf_chk(varp, nbuf);
       if (!error && strval != NULL) {
         set_option_value(varname, numval, strval, OPT_LOCAL);
       }
@@ -14438,17 +14429,17 @@ static void f_setfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   rettv->vval.v_number = 0;
 
-  char_u *fname = get_tv_string_chk(&argvars[0]);
+  const char *const fname = tv_get_string_chk(&argvars[0]);
   if (fname == NULL) {
     return;
   }
 
-  char_u modebuf[NUMBUFLEN];
-  char_u *mode_str = get_tv_string_buf_chk(&argvars[1], modebuf);
+  char modebuf[NUMBUFLEN];
+  const char *const mode_str = tv_get_string_buf_chk(&argvars[1], modebuf);
   if (mode_str == NULL) {
     return;
   }
-  if (STRLEN(mode_str) != 9) {
+  if (strlen(mode_str) != 9) {
     EMSG2(_(e_invarg2), mode_str);
     return;
   }
@@ -14469,26 +14460,28 @@ static void f_setfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_setline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *line = NULL;
   list_T      *l = NULL;
   listitem_T  *li = NULL;
   long added = 0;
   linenr_T lcount = curbuf->b_ml.ml_line_count;
 
   linenr_T lnum = tv_get_lnum(&argvars[0]);
+  const char *line = NULL;
   if (argvars[1].v_type == VAR_LIST) {
     l = argvars[1].vval.v_list;
     li = l->lv_first;
-  } else
-    line = get_tv_string_chk(&argvars[1]);
+  } else {
+    line = tv_get_string_chk(&argvars[1]);
+  }
 
   /* default result is zero == OK */
   for (;; ) {
     if (l != NULL) {
-      /* list argument, get next string */
-      if (li == NULL)
+      // List argument, get next string.
+      if (li == NULL) {
         break;
-      line = get_tv_string_chk(&li->li_tv);
+      }
+      line = tv_get_string_chk(&li->li_tv);
       li = li->li_next;
     }
 
@@ -14504,18 +14497,20 @@ static void f_setline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
 
     if (lnum <= curbuf->b_ml.ml_line_count) {
-      /* existing line, replace it */
-      if (u_savesub(lnum) == OK && ml_replace(lnum, line, TRUE) == OK) {
+      // Existing line, replace it.
+      if (u_savesub(lnum) == OK
+          && ml_replace(lnum, (char_u *)line, true) == OK) {
         changed_bytes(lnum, 0);
         if (lnum == curwin->w_cursor.lnum)
           check_cursor_col();
         rettv->vval.v_number = 0;               /* OK */
       }
     } else if (added > 0 || u_save(lnum - 1, lnum) == OK) {
-      /* lnum is one past the last line, append the line */
-      ++added;
-      if (ml_append(lnum - 1, line, (colnr_T)0, FALSE) == OK)
-        rettv->vval.v_number = 0;               /* OK */
+      // lnum is one past the last line, append the line.
+      added++;
+      if (ml_append(lnum - 1, (char_u *)line, 0, false) == OK) {
+        rettv->vval.v_number = 0;  // OK
+      }
     }
 
     if (l == NULL)                      /* only one string argument */
@@ -14544,7 +14539,7 @@ static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
   FUNC_ATTR_NONNULL_ARG(2, 3)
 {
   static char *e_invact = N_("E927: Invalid action: '%s'");
-  char_u *title = NULL;
+  const char *title = NULL;
   int action = ' ';
   rettv->vval.v_number = -1;
   dict_T *d = NULL;
@@ -14563,7 +14558,7 @@ static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
     EMSG(_(e_stringreq));
     return;
   }
-  char_u *act = get_tv_string_chk(action_arg);
+  const char *const act = tv_get_string_chk(action_arg);
   if ((*act == 'a' || *act == 'r' || *act == ' ') && act[1] == NUL) {
     action = *act;
   } else {
@@ -14576,7 +14571,7 @@ static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
     // Option argument was not given.
     goto skip_args;
   } else if (title_arg->v_type == VAR_STRING) {
-    title = get_tv_string_chk(title_arg);
+    title = tv_get_string_chk(title_arg);
     if (!title) {
       // Type error. Error already printed by get_tv_string_chk().
       return;
@@ -14584,17 +14579,17 @@ static void set_qf_ll_list(win_T *wp, typval_T *args, typval_T *rettv)
   } else if (title_arg->v_type == VAR_DICT) {
     d = title_arg->vval.v_dict;
   } else {
-    EMSG(_(e_dictreq));
+    emsgf(_(e_dictreq));
     return;
   }
 
 skip_args:
   if (!title) {
-    title = (char_u*)(wp ? "setloclist()" : "setqflist()");
+    title = (wp ? "setloclist()" : "setqflist()");
   }
 
   list_T *l = list_arg->vval.v_list;
-  if (l && set_errorlist(wp, l, action, title, d) == OK) {
+  if (l && set_errorlist(wp, l, action, (char_u *)title, d) == OK) {
     rettv->vval.v_number = 0;
   }
 }
@@ -14728,11 +14723,10 @@ static void f_setpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   pos_T pos;
   int fnum;
-  char_u      *name;
   colnr_T     curswant = -1;
 
   rettv->vval.v_number = -1;
-  name = get_tv_string_chk(argvars);
+  const char *const name = tv_get_string_chk(argvars);
   if (name != NULL) {
     if (list2fpos(&argvars[1], &pos, &fnum, &curswant) == OK) {
       if (--pos.col < 0) {
@@ -14753,7 +14747,7 @@ static void f_setpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         }
       } else if (name[0] == '\'' && name[1] != NUL && name[2] == NUL)   {
         // set mark
-        if (setmark_pos(name[1], &pos, fnum) == OK) {
+        if (setmark_pos((uint8_t)name[1], &pos, fnum) == OK) {
           rettv->vval.v_number = 0;
         }
       } else {
@@ -14777,8 +14771,6 @@ static void f_setqflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_setreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int regname;
-  char_u      *strregname;
-  char_u      *stropt;
   bool append = false;
   MotionType yank_type;
   long block_len;
@@ -14786,39 +14778,47 @@ static void f_setreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   block_len = -1;
   yank_type = kMTUnknown;
 
-  strregname = get_tv_string_chk(argvars);
-  rettv->vval.v_number = 1;             /* FAIL is default */
+  rettv->vval.v_number = 1;  // FAIL is default.
 
-  if (strregname == NULL)
-    return;             /* type error; errmsg already given */
-  regname = *strregname;
-  if (regname == 0 || regname == '@')
+  const char *const strregname = tv_get_string_chk(argvars);
+  if (strregname == NULL) {
+    return;  // Type error; errmsg already given.
+  }
+  regname = (uint8_t)(*strregname);
+  if (regname == 0 || regname == '@') {
     regname = '"';
+  }
 
   if (argvars[2].v_type != VAR_UNKNOWN) {
-    stropt = get_tv_string_chk(&argvars[2]);
-    if (stropt == NULL)
-      return;                   /* type error */
-    for (; *stropt != NUL; ++stropt)
+    const char *stropt = tv_get_string_chk(&argvars[2]);
+    if (stropt == NULL) {
+      return;  // Type error.
+    }
+    for (; *stropt != NUL; stropt++) {
       switch (*stropt) {
-      case 'a': case 'A':  // append
-        append = true;
-        break;
-      case 'v': case 'c':  // character-wise selection
-        yank_type = kMTCharWise;
-        break;
-      case 'V': case 'l':  // line-wise selection
-        yank_type = kMTLineWise;
-        break;
-      case 'b': case Ctrl_V:  // block-wise selection
-        yank_type = kMTBlockWise;
-        if (ascii_isdigit(stropt[1])) {
-          ++stropt;
-          block_len = getdigits_long(&stropt) - 1;
-          --stropt;
+        case 'a': case 'A': {  // append
+          append = true;
+          break;
+        }
+        case 'v': case 'c': {  // character-wise selection
+          yank_type = kMTCharWise;
+          break;
+        }
+        case 'V': case 'l': {  // line-wise selection
+          yank_type = kMTLineWise;
+          break;
+        }
+        case 'b': case Ctrl_V: {  // block-wise selection
+          yank_type = kMTBlockWise;
+          if (ascii_isdigit(stropt[1])) {
+            stropt++;
+            block_len = getdigits_long((char_u **)&stropt) - 1;
+            stropt--;
+          }
+          break;
         }
-        break;
       }
+    }
   }
 
   if (argvars[1].v_type == VAR_LIST) {
@@ -14828,42 +14828,44 @@ static void f_setreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
     // First half: use for pointers to result lines; second half: use for
     // pointers to allocated copies.
-    char_u **lstval = xmalloc(sizeof(char_u *) * ((len + 1) * 2));
-    char_u **curval = lstval;
-    char_u **allocval = lstval + len + 2;
-    char_u **curallocval = allocval;
+    char **lstval = xmalloc(sizeof(char *) * ((len + 1) * 2));
+    const char **curval = (const char **)lstval;
+    char **allocval = lstval + len + 2;
+    char **curallocval = allocval;
 
-    char_u buf[NUMBUFLEN];
     for (listitem_T *li = ll == NULL ? NULL : ll->lv_first;
          li != NULL;
          li = li->li_next) {
-      char_u *strval = get_tv_string_buf_chk(&li->li_tv, buf);
-      if (strval == NULL) {
+      char buf[NUMBUFLEN];
+      *curval = tv_get_string_buf_chk(&li->li_tv, buf);
+      if (*curval == NULL) {
         goto free_lstval;
       }
-      if (strval == buf) {
+      if (*curval == buf) {
         // Need to make a copy,
-        // next get_tv_string_buf_chk() will overwrite the string.
-        strval = vim_strsave(buf);
-        *curallocval++ = strval;
+        // next tv_get_string_buf_chk() will overwrite the string.
+        *curallocval = xstrdup(*curval);
+        *curval = *curallocval;
+        curallocval++;
       }
-      *curval++ = strval;
+      curval++;
     }
     *curval++ = NULL;
 
-    write_reg_contents_lst(regname, lstval, STRLEN(lstval),
-                           append, yank_type, block_len);
+    write_reg_contents_lst(regname, (char_u **)lstval, append, yank_type,
+                           block_len);
 
 free_lstval:
-    while (curallocval > allocval)
-        xfree(*--curallocval);
+    while (curallocval > allocval) {
+      xfree(*--curallocval);
+    }
     xfree(lstval);
   } else {
-    char_u *strval = get_tv_string_chk(&argvars[1]);
+    const char *strval = tv_get_string_chk(&argvars[1]);
     if (strval == NULL) {
       return;
     }
-    write_reg_contents_ex(regname, strval, STRLEN(strval),
+    write_reg_contents_ex(regname, (const char_u *)strval, STRLEN(strval),
                           append, yank_type, block_len);
   }
   rettv->vval.v_number = 0;
@@ -14881,7 +14883,7 @@ static void f_settabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   tabpage_T *const tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
-  const char *const varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *const varname = tv_get_string_chk(&argvars[1]);
   typval_T *const varp = &argvars[2];
 
   if (varname != NULL && varp != NULL && tp != NULL) {
@@ -14935,7 +14937,7 @@ static void setwinvar(typval_T *argvars, typval_T *rettv, int off)
     tp = curtab;
   }
   win_T *const win = find_win_by_nr(&argvars[off], tp);
-  const char *varname = (const char *)get_tv_string_chk(&argvars[off + 1]);
+  const char *varname = tv_get_string_chk(&argvars[off + 1]);
   typval_T *varp = &argvars[off + 2];
 
   if (win != NULL && varname != NULL && varp != NULL) {
@@ -14950,8 +14952,8 @@ static void setwinvar(typval_T *argvars, typval_T *rettv, int off)
 
         varname++;
         numval = tv_get_number_chk(varp, &error);
-        char_u nbuf[NUMBUFLEN];
-        char *const strval = (char *)get_tv_string_buf_chk(varp, nbuf);
+        char nbuf[NUMBUFLEN];
+        const char *const strval = tv_get_string_buf_chk(varp, nbuf);
         if (!error && strval != NULL) {
           set_option_value(varname, numval, strval, OPT_LOCAL);
         }
@@ -15415,25 +15417,26 @@ static void f_soundfold(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_spellbadword(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *word = (char_u *)"";
+  const char *word = "";
   hlf_T attr = HLF_COUNT;
   size_t len = 0;
 
   tv_list_alloc_ret(rettv);
 
   if (argvars[0].v_type == VAR_UNKNOWN) {
-    /* Find the start and length of the badly spelled word. */
-    len = spell_move_to(curwin, FORWARD, TRUE, TRUE, &attr);
-    if (len != 0)
-      word = get_cursor_pos_ptr();
+    // Find the start and length of the badly spelled word.
+    len = spell_move_to(curwin, FORWARD, true, true, &attr);
+    if (len != 0) {
+      word = (char *)get_cursor_pos_ptr();
+    }
   } else if (curwin->w_p_spell && *curbuf->b_s.b_p_spl != NUL) {
-    char_u  *str = get_tv_string_chk(&argvars[0]);
+    const char *str = tv_get_string_chk(&argvars[0]);
     int capcol = -1;
 
     if (str != NULL) {
-      /* Check the argument for spelling. */
+      // Check the argument for spelling.
       while (*str != NUL) {
-        len = spell_check(curwin, str, &attr, &capcol, false);
+        len = spell_check(curwin, (char_u *)str, &attr, &capcol, false);
         if (attr != HLF_COUNT) {
           word = str;
           break;
@@ -15444,7 +15447,7 @@ static void f_spellbadword(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   assert(len <= INT_MAX);
-  tv_list_append_string(rettv->vval.v_list, (const char *)word, len);
+  tv_list_append_string(rettv->vval.v_list, word, len);
   tv_list_append_string(rettv->vval.v_list,
                         (attr == HLF_SPB ? "bad"
                          : attr == HLF_SPR ? "rare"
@@ -15499,9 +15502,7 @@ static void f_spellsuggest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void f_split(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *pat = NULL;
   regmatch_T regmatch;
-  char_u patbuf[NUMBUFLEN];
   char_u      *save_cpo;
   int match;
   colnr_T col = 0;
@@ -15513,8 +15514,10 @@ static void f_split(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   p_cpo = (char_u *)"";
 
   const char *str = tv_get_string(&argvars[0]);
+  const char *pat = NULL;
+  char patbuf[NUMBUFLEN];
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    pat = get_tv_string_buf_chk(&argvars[1], patbuf);
+    pat = tv_get_string_buf_chk(&argvars[1], patbuf);
     if (pat == NULL) {
       typeerr = true;
     }
@@ -15522,15 +15525,16 @@ static void f_split(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       keepempty = (bool)tv_get_number_chk(&argvars[2], &typeerr);
     }
   }
-  if (pat == NULL || *pat == NUL)
-    pat = (char_u *)"[\\x01- ]\\+";
+  if (pat == NULL || *pat == NUL) {
+    pat = "[\\x01- ]\\+";
+  }
 
   tv_list_alloc_ret(rettv);
 
   if (typeerr)
     return;
 
-  regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
+  regmatch.regprog = vim_regcomp((char_u *)pat, RE_MAGIC + RE_STRING);
   if (regmatch.regprog != NULL) {
     regmatch.rm_ic = FALSE;
     while (*str != NUL || keepempty) {
@@ -15682,7 +15686,7 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   rettv->vval.v_number = -1;
 
-  char_u *str = get_tv_string_chk(&argvars[0]);
+  const char *const str = tv_get_string_chk(&argvars[0]);
   if (str == NULL) {
     return;
   }
@@ -15697,11 +15701,11 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   while (charidx >= 0 && byteidx < len) {
     if (charidx == 0) {
-      rettv->vval.v_number = mb_ptr2char(str + byteidx);
+      rettv->vval.v_number = mb_ptr2char((const char_u *)str + byteidx);
       break;
     }
     charidx--;
-    byteidx += MB_CPTR2LEN(str + byteidx);
+    byteidx += MB_CPTR2LEN((const char_u *)str + byteidx);
   }
 }
 
@@ -15710,24 +15714,22 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_stridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u buf[NUMBUFLEN];
-  char_u      *needle;
-  char_u      *haystack;
-  char_u      *save_haystack;
-  char_u      *pos;
-  int start_idx;
-
-  needle = get_tv_string_chk(&argvars[1]);
-  save_haystack = haystack = get_tv_string_buf_chk(&argvars[0], buf);
   rettv->vval.v_number = -1;
-  if (needle == NULL || haystack == NULL)
-    return;             /* type error; errmsg already given */
+
+  char buf[NUMBUFLEN];
+  const char *const needle = tv_get_string_chk(&argvars[1]);
+  const char *haystack = tv_get_string_buf_chk(&argvars[0], buf);
+  const char *const haystack_start = haystack;
+  if (needle == NULL || haystack == NULL) {
+    return;  // Type error; errmsg already given.
+  }
 
   if (argvars[2].v_type != VAR_UNKNOWN) {
     bool error = false;
 
-    start_idx = tv_get_number_chk(&argvars[2], &error);
-    if (error || start_idx >= (int)STRLEN(haystack)) {
+    const ptrdiff_t start_idx = (ptrdiff_t)tv_get_number_chk(&argvars[2],
+                                                             &error);
+    if (error || start_idx >= (ptrdiff_t)strlen(haystack)) {
       return;
     }
     if (start_idx >= 0) {
@@ -15735,9 +15737,10 @@ static void f_stridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   }
 
-  pos = (char_u *)strstr((char *)haystack, (char *)needle);
-  if (pos != NULL)
-    rettv->vval.v_number = (varnumber_T)(pos - save_haystack);
+  const char *pos = strstr(haystack, needle);
+  if (pos != NULL) {
+    rettv->vval.v_number = (varnumber_T)(pos - haystack_start);
+  }
 }
 
 /*
@@ -15765,7 +15768,7 @@ static void f_strchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   const char *s = tv_get_string(&argvars[0]);
   int skipcc = 0;
   varnumber_T len = 0;
-  int (*func_mb_ptr2char_adv)(char_u **pp);
+  int (*func_mb_ptr2char_adv)(const char_u **pp);
 
   if (argvars[1].v_type != VAR_UNKNOWN) {
     skipcc = tv_get_number_chk(&argvars[1], NULL);
@@ -15775,7 +15778,7 @@ static void f_strchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   } else {
     func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;
     while (*s != NUL) {
-      func_mb_ptr2char_adv((char_u **)&s);
+      func_mb_ptr2char_adv((const char_u **)&s);
       len++;
     }
     rettv->vval.v_number = len;
@@ -15904,47 +15907,46 @@ static void f_strpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_strridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u buf[NUMBUFLEN];
-  char_u      *needle;
-  char_u      *haystack;
-  char_u      *rest;
-  char_u      *lastmatch = NULL;
-  int haystack_len, end_idx;
-
-  needle = get_tv_string_chk(&argvars[1]);
-  haystack = get_tv_string_buf_chk(&argvars[0], buf);
+  char buf[NUMBUFLEN];
+  const char *const needle = tv_get_string_chk(&argvars[1]);
+  const char *const haystack = tv_get_string_buf_chk(&argvars[0], buf);
 
   rettv->vval.v_number = -1;
-  if (needle == NULL || haystack == NULL)
-    return;             /* type error; errmsg already given */
+  if (needle == NULL || haystack == NULL) {
+    return;  // Type error; errmsg already given.
+  }
 
-  haystack_len = (int)STRLEN(haystack);
+  const size_t haystack_len = STRLEN(haystack);
+  ptrdiff_t end_idx;
   if (argvars[2].v_type != VAR_UNKNOWN) {
     // Third argument: upper limit for index.
-    end_idx = tv_get_number_chk(&argvars[2], NULL);
+    end_idx = (ptrdiff_t)tv_get_number_chk(&argvars[2], NULL);
     if (end_idx < 0) {
       return;  // Can never find a match.
     }
   } else {
-    end_idx = haystack_len;
+    end_idx = (ptrdiff_t)haystack_len;
   }
 
+  const char *lastmatch = NULL;
   if (*needle == NUL) {
-    /* Empty string matches past the end. */
+    // Empty string matches past the end.
     lastmatch = haystack + end_idx;
   } else {
-    for (rest = haystack; *rest != NUL; ++rest) {
-      rest = (char_u *)strstr((char *)rest, (char *)needle);
-      if (rest == NULL || rest > haystack + end_idx)
+    for (const char *rest = haystack; *rest != NUL; rest++) {
+      rest = strstr(rest, needle);
+      if (rest == NULL || rest > haystack + end_idx) {
         break;
+      }
       lastmatch = rest;
     }
   }
 
-  if (lastmatch == NULL)
+  if (lastmatch == NULL) {
     rettv->vval.v_number = -1;
-  else
+  } else {
     rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
+  }
 }
 
 /*
@@ -15994,20 +15996,20 @@ static void f_submatch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_substitute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u patbuf[NUMBUFLEN];
-  char_u subbuf[NUMBUFLEN];
-  char_u flagsbuf[NUMBUFLEN];
+  char patbuf[NUMBUFLEN];
+  char subbuf[NUMBUFLEN];
+  char flagsbuf[NUMBUFLEN];
 
-  char_u      *str = get_tv_string_chk(&argvars[0]);
-  char_u      *pat = get_tv_string_buf_chk(&argvars[1], patbuf);
-  char_u      *sub = NULL;
-  typval_T    *expr = NULL;
-  char_u      *flg = get_tv_string_buf_chk(&argvars[3], flagsbuf);
+  const char *const str = tv_get_string_chk(&argvars[0]);
+  const char *const pat = tv_get_string_buf_chk(&argvars[1], patbuf);
+  const char *sub = NULL;
+  const char *const flg = tv_get_string_buf_chk(&argvars[3], flagsbuf);
 
+  typval_T *expr = NULL;
   if (argvars[2].v_type == VAR_FUNC || argvars[2].v_type == VAR_PARTIAL) {
     expr = &argvars[2];
   } else {
-    sub = get_tv_string_buf_chk(&argvars[2], subbuf);
+    sub = tv_get_string_buf_chk(&argvars[2], subbuf);
   }
 
   rettv->v_type = VAR_STRING;
@@ -16015,7 +16017,8 @@ static void f_substitute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       || flg == NULL) {
     rettv->vval.v_string = NULL;
   } else {
-    rettv->vval.v_string = do_string_sub(str, pat, sub, expr, flg);
+    rettv->vval.v_string = do_string_sub((char_u *)str, (char_u *)pat,
+                                         (char_u *)sub, expr, (char_u *)flg);
   }
 }
 
@@ -16333,19 +16336,20 @@ static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_tabpagenr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int nr = 1;
-  char_u      *arg;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
-    arg = get_tv_string_chk(&argvars[0]);
+    const char *const arg = tv_get_string_chk(&argvars[0]);
     nr = 0;
     if (arg != NULL) {
-      if (STRCMP(arg, "$") == 0)
+      if (strcmp(arg, "$") == 0) {
         nr = tabpage_index(NULL) - 1;
-      else
+      } else {
         EMSG2(_(e_invexpr2), arg);
+      }
     }
-  } else
+  } else {
     nr = tabpage_index(curtab);
+  }
   rettv->vval.v_number = nr;
 }
 
@@ -16359,19 +16363,19 @@ static int get_winnr(tabpage_T *tp, typval_T *argvar)
   win_T       *twin;
   int nr = 1;
   win_T       *wp;
-  char_u      *arg;
 
   twin = (tp == curtab) ? curwin : tp->tp_curwin;
   if (argvar->v_type != VAR_UNKNOWN) {
-    arg = get_tv_string_chk(argvar);
-    if (arg == NULL)
-      nr = 0;                   /* type error; errmsg already given */
-    else if (STRCMP(arg, "$") == 0)
+    const char *const arg = tv_get_string_chk(argvar);
+    if (arg == NULL) {
+      nr = 0;  // Type error; errmsg already given.
+    } else if (strcmp(arg, "$") == 0) {
       twin = (tp == curtab) ? lastwin : tp->tp_lastwin;
-    else if (STRCMP(arg, "#") == 0) {
+    } else if (strcmp(arg, "#") == 0) {
       twin = (tp == curtab) ? prevwin : tp->tp_prevwin;
-      if (twin == NULL)
+      if (twin == NULL) {
         nr = 0;
+      }
     } else {
       EMSG2(_(e_invexpr2), arg);
       nr = 0;
@@ -16853,28 +16857,25 @@ static void f_toupper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_tr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  int fromlen;
-  int tolen;
-  int idx;
-  char_u buf[NUMBUFLEN];
-  char_u buf2[NUMBUFLEN];
-  garray_T ga;
+  char buf[NUMBUFLEN];
+  char buf2[NUMBUFLEN];
 
   const char *in_str = tv_get_string(&argvars[0]);
-  const char_u *fromstr = get_tv_string_buf_chk(&argvars[1], buf);
-  const char_u *tostr = get_tv_string_buf_chk(&argvars[2], buf2);
+  const char *fromstr = tv_get_string_buf_chk(&argvars[1], buf);
+  const char *tostr = tv_get_string_buf_chk(&argvars[2], buf2);
 
   // Default return value: empty string.
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
   if (fromstr == NULL || tostr == NULL) {
-    return;  // type error; errmsg already given
+    return;  // Type error; errmsg already given.
   }
+  garray_T ga;
   ga_init(&ga, (int)sizeof(char), 80);
 
   if (!has_mbyte) {
     // Not multi-byte: fromstr and tostr must be the same length.
-    if (STRLEN(fromstr) != STRLEN(tostr)) {
+    if (strlen(fromstr) != strlen(tostr)) {
       goto error;
     }
   }
@@ -16886,23 +16887,26 @@ static void f_tr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       const char *cpstr = in_str;
       const int inlen = (*mb_ptr2len)((const char_u *)in_str);
       int cplen = inlen;
-      idx = 0;
-      for (const char_u *p = fromstr; *p != NUL; p += fromlen) {
-        fromlen = (*mb_ptr2len)(p);
+      int idx = 0;
+      int fromlen;
+      for (const char *p = fromstr; *p != NUL; p += fromlen) {
+        fromlen = (*mb_ptr2len)((const char_u *)p);
         if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0) {
+          int tolen;
           for (p = tostr; *p != NUL; p += tolen) {
-            tolen = (*mb_ptr2len)(p);
+            tolen = (*mb_ptr2len)((const char_u *)p);
             if (idx-- == 0) {
               cplen = tolen;
               cpstr = (char *)p;
               break;
             }
           }
-          if (*p == NUL)                /* tostr is shorter than fromstr */
+          if (*p == NUL) {  // tostr is shorter than fromstr.
             goto error;
+          }
           break;
         }
-        ++idx;
+        idx++;
       }
 
       if (first && cpstr == in_str) {
@@ -16910,8 +16914,9 @@ static void f_tr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         // (multi-byte) characters.  Done only once when a character
         // of in_str doesn't appear in fromstr.
         first = false;
-        for (const char_u *p = tostr; *p != NUL; p += tolen) {
-          tolen = (*mb_ptr2len)(p);
+        int tolen;
+        for (const char *p = tostr; *p != NUL; p += tolen) {
+          tolen = (*mb_ptr2len)((const char_u *)p);
           idx--;
         }
         if (idx != 0) {
@@ -16926,7 +16931,7 @@ static void f_tr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       in_str += inlen;
     } else {
       // When not using multi-byte chars we can do it faster.
-      char_u *p = vim_strchr(fromstr, *in_str);
+      const char *const p = strchr(fromstr, *in_str);
       if (p != NULL) {
         ga_append(&ga, tostr[p - fromstr]);
       } else {
@@ -17278,8 +17283,7 @@ static bool write_list(FileDescriptor *const fp, const list_T *const list,
 {
   int error = 0;
   for (const listitem_T *li = list->lv_first; li != NULL; li = li->li_next) {
-    const char *const s = (const char *)get_tv_string_chk(
-        (typval_T *)&li->li_tv);
+    const char *const s = tv_get_string_chk(&li->li_tv);
     if (s == NULL) {
       return false;
     }
@@ -17368,17 +17372,16 @@ static char *save_tv_as_string(typval_T *tv, ptrdiff_t *const len, bool endnl)
     return NULL;
   }
 
-  // For types other than list, let get_tv_string_buf_chk() get the value or
+  // For types other than list, let tv_get_string_buf_chk() get the value or
   // print an error.
   if (tv->v_type != VAR_LIST) {
-    char *ret = (char *)get_tv_string_chk(tv);
+    const char *ret = tv_get_string_chk(tv);
     if (ret && (*len = strlen(ret))) {
-      ret = xstrdup(ret);
+      return xmemdupz(ret, (size_t)(*len));
     } else {
-      ret = NULL;
       *len = -1;
+      return NULL;
     }
-    return ret;
   }
 
   // Pre-calculate the resulting length.
@@ -17448,7 +17451,7 @@ static void f_writefile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   bool binary = false;
   bool append = false;
   if (argvars[2].v_type != VAR_UNKNOWN) {
-    const char *const flags = (const char *)get_tv_string_chk(&argvars[2]);
+    const char *const flags = tv_get_string_chk(&argvars[2]);
     if (flags == NULL) {
       return;
     }
@@ -17460,9 +17463,8 @@ static void f_writefile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   }
 
-  const char buf[NUMBUFLEN];
-  const char *const fname = (const char *)get_tv_string_buf_chk(&argvars[1],
-                                                                (char_u *)buf);
+  char buf[NUMBUFLEN];
+  const char *const fname = tv_get_string_buf_chk(&argvars[1], buf);
   if (fname == NULL) {
     return;
   }
@@ -17510,7 +17512,6 @@ pos_T *var2fpos(const typval_T *const tv, const int dollar_lnum,
                 int *const ret_fnum)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  char_u              *name;
   static pos_T pos;
   pos_T               *pp;
 
@@ -17564,7 +17565,7 @@ pos_T *var2fpos(const typval_T *const tv, const int dollar_lnum,
     return &pos;
   }
 
-  name = get_tv_string_chk(tv);
+  const char *const name = tv_get_string_chk(tv);
   if (name == NULL) {
     return NULL;
   }
@@ -17578,7 +17579,7 @@ pos_T *var2fpos(const typval_T *const tv, const int dollar_lnum,
     return &curwin->w_cursor;
   }
   if (name[0] == '\'') {  // Mark.
-    pp = getmark_buf_fnum(curbuf, name[1], false, ret_fnum);
+    pp = getmark_buf_fnum(curbuf, (uint8_t)name[1], false, ret_fnum);
     if (pp == NULL || pp == (pos_T *)-1 || pp->lnum <= 0) {
       return NULL;
     }
@@ -18403,58 +18404,11 @@ void set_selfdict(typval_T *rettv, dict_T *selfdict)
   }
 }
 
-// TODO(ZyX-I): move to eval/typval
-
-/// Careful: This uses a single, static buffer.  YOU CAN ONLY USE IT ONCE!
-char_u *get_tv_string_chk(const typval_T *varp)
-  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
-{
-  static char_u mybuf[NUMBUFLEN];
-
-  return get_tv_string_buf_chk(varp, mybuf);
-}
-
-char_u *get_tv_string_buf_chk(const typval_T *varp, char_u *buf)
-  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
-{
-  switch (varp->v_type) {
-  case VAR_NUMBER:
-    sprintf((char *)buf, "%" PRId64, (int64_t)varp->vval.v_number);
-    return buf;
-  case VAR_FUNC:
-  case VAR_PARTIAL:
-    EMSG(_("E729: using Funcref as a String"));
-    break;
-  case VAR_LIST:
-    EMSG(_("E730: using List as a String"));
-    break;
-  case VAR_DICT:
-    EMSG(_("E731: using Dictionary as a String"));
-    break;
-  case VAR_FLOAT:
-    EMSG(_(e_float_as_string));
-    break;
-  case VAR_STRING:
-    if (varp->vval.v_string != NULL)
-      return varp->vval.v_string;
-    return (char_u *)"";
-  case VAR_SPECIAL:
-    STRCPY(buf, encode_special_var_names[varp->vval.v_special]);
-    return buf;
-  case VAR_UNKNOWN:
-    EMSG(_("E908: using an invalid value as a String"));
-    break;
-  }
-  return NULL;
-}
-
-/*
- * Find variable "name" in the list of variables.
- * Return a pointer to it if found, NULL if not found.
- * Careful: "a:0" variables don't have a name.
- * When "htp" is not NULL we are writing to the variable, set "htp" to the
- * hashtab_T used.
- */
+// Find variable "name" in the list of variables.
+// Return a pointer to it if found, NULL if not found.
+// Careful: "a:0" variables don't have a name.
+// When "htp" is not NULL we are writing to the variable, set "htp" to the
+// hashtab_T used.
 static dictitem_T *find_var(const char *const name, const size_t name_len,
                             hashtab_T **htp, int no_autoload)
 {
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index ca635dcae9..78eca15fec 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -796,7 +796,7 @@ static bool tv_dict_watcher_matches(DictWatcher *watcher, const char *const key)
   // of the string means it should match everything up to the '*' instead of the
   // whole string.
   const size_t len = strlen(watcher->key_pattern);
-  if (watcher->key_pattern[len - 1] == '*') {
+  if (len && watcher->key_pattern[len - 1] == '*') {
     return strncmp(key, watcher->key_pattern, len - 1) == 0;
   } else {
     return strcmp(key, watcher->key_pattern) == 0;
@@ -2020,7 +2020,7 @@ bool tv_equal(typval_T *const tv1, typval_T *const tv2, const bool ic,
 ///
 /// @return true if everything is OK, false otherwise.
 bool tv_check_str_or_nr(const typval_T *const tv)
-  FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
+  FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
   switch (tv->v_type) {
     case VAR_NUMBER:
@@ -2072,7 +2072,7 @@ static const char *const num_errors[] = {
 
 /// Check that given value is a number or can be converted to it
 ///
-/// Error messages are compatible with tv_get_number() previously used for
+/// Error messages are compatible with tv_get_number_chk() previously used for
 /// the same purpose.
 ///
 /// @param[in]  tv  Value to check.
@@ -2101,6 +2101,50 @@ bool tv_check_num(const typval_T *const tv)
   return false;
 }
 
+#define FUNC_ERROR "E729: using Funcref as a String"
+
+static const char *const str_errors[] = {
+  [VAR_PARTIAL]=N_(FUNC_ERROR),
+  [VAR_FUNC]=N_(FUNC_ERROR),
+  [VAR_LIST]=N_("E730: using List as a String"),
+  [VAR_DICT]=N_("E731: using Dictionary as a String"),
+  [VAR_FLOAT]=((const char *)e_float_as_string),
+  [VAR_UNKNOWN]=N_("E908: using an invalid value as a String"),
+};
+
+#undef FUNC_ERROR
+
+/// Check that given value is a string or can be converted to it
+///
+/// Error messages are compatible with tv_get_string_chk() previously used for
+/// the same purpose.
+///
+/// @param[in]  tv  Value to check.
+///
+/// @return true if everything is OK, false otherwise.
+bool tv_check_str(const typval_T *const tv)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  switch (tv->v_type) {
+    case VAR_NUMBER:
+    case VAR_SPECIAL:
+    case VAR_STRING: {
+      return true;
+    }
+    case VAR_PARTIAL:
+    case VAR_FUNC:
+    case VAR_LIST:
+    case VAR_DICT:
+    case VAR_FLOAT:
+    case VAR_UNKNOWN: {
+      EMSG(_(str_errors[tv->v_type]));
+      return false;
+    }
+  }
+  assert(false);
+  return false;
+}
+
 //{{{2 Get
 
 /// Get the number value of a VimL object
@@ -2247,12 +2291,73 @@ float_T tv_get_float(const typval_T *const tv)
 
 /// Get the string value of a VimL object
 ///
+/// @param[in]  tv  Object to get value of.
+/// @param  buf  Buffer used to hold numbers and special variables converted to
+///              string. When function encounters one of these stringified value
+///              will be written to buf and buf will be returned.
+///
+///              Buffer must have NUMBUFLEN size.
+///
+/// @return Object value if it is VAR_STRING object, number converted to
+///         a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or NULL.
+const char *tv_get_string_buf_chk(const typval_T *const tv, char *const buf)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  switch (tv->v_type) {
+    case VAR_NUMBER: {
+      snprintf(buf, NUMBUFLEN, "%" PRIdVARNUMBER, tv->vval.v_number);
+      return buf;
+    }
+    case VAR_STRING: {
+      if (tv->vval.v_string != NULL) {
+        return (const char *)tv->vval.v_string;
+      }
+      return "";
+    }
+    case VAR_SPECIAL: {
+      STRCPY(buf, encode_special_var_names[tv->vval.v_special]);
+      return buf;
+    }
+    case VAR_PARTIAL:
+    case VAR_FUNC:
+    case VAR_LIST:
+    case VAR_DICT:
+    case VAR_FLOAT:
+    case VAR_UNKNOWN: {
+      EMSG(_(str_errors[tv->v_type]));
+      return false;
+    }
+  }
+  return NULL;
+}
+
+/// Get the string value of a VimL object
+///
+/// @warning For number and special values it uses a single, static buffer. It
+///          may be used only once, next call to get_tv_string may reuse it. Use
+///          tv_get_string_buf() if you need to use tv_get_string() output after
+///          calling it again.
+///
+/// @param[in]  tv  Object to get value of.
+///
+/// @return Object value if it is VAR_STRING object, number converted to
+///         a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or NULL.
+const char *tv_get_string_chk(const typval_T *const tv)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  static char mybuf[NUMBUFLEN];
+
+  return tv_get_string_buf_chk(tv, mybuf);
+}
+
+/// Get the string value of a VimL object
+///
 /// @warning For number and special values it uses a single, static buffer. It
 ///          may be used only once, next call to get_tv_string may reuse it. Use
 ///          tv_get_string_buf() if you need to use tv_get_string() output after
 ///          calling it again.
 ///
-/// @note get_tv_string_chk() and get_tv_string_buf_chk() are similar, but
+/// @note tv_get_string_chk() and tv_get_string_buf_chk() are similar, but
 ///       return NULL on error.
 ///
 /// @param[in]  tv  Object to get value of.
@@ -2269,7 +2374,7 @@ const char *tv_get_string(const typval_T *const tv)
 
 /// Get the string value of a VimL object
 ///
-/// @note get_tv_string_chk() and get_tv_string_buf_chk() are similar, but
+/// @note tv_get_string_chk() and tv_get_string_buf_chk() are similar, but
 ///       return NULL on error.
 ///
 /// @param[in]  tv  Object to get value of.
@@ -2285,8 +2390,7 @@ const char *tv_get_string(const typval_T *const tv)
 const char *tv_get_string_buf(const typval_T *const tv, char *const buf)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  const char *const res = (const char *)get_tv_string_buf_chk(
-      (typval_T *)tv, (char_u *)buf);
+  const char *const res = (const char *)tv_get_string_buf_chk(tv, buf);
 
   return res != NULL ? res : "";
 }
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index 3c294b45b8..42581939e3 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -27,6 +27,7 @@ typedef double float_T;
 
 /// Mimimal possible value of varnumber_T variable
 #define VARNUMBER_MIN INT_MIN
+#define PRIdVARNUMBER "d"
 
 /// %d printf format specifier for varnumber_T
 #define PRIdVARNUMBER "d"
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 9681527fee..9a847a4c0a 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1008,8 +1008,8 @@ void do_bang(int addr_count, exarg_T *eap, int forceit, int do_in, int do_out)
 
     AppendToRedobuffLit(cmd, -1);
     xfree(cmd);
-    AppendToRedobuff((char_u *)"\n");
-    bangredo = FALSE;
+    AppendToRedobuff("\n");
+    bangredo = false;
   }
   /*
    * Add quotes around the command, for shells that need them.
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 6b661cff11..73b81ac2d9 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -6794,7 +6794,7 @@ do_exedit (
         int ms = msg_scroll;
 
         if (eap->nextcmd != NULL) {
-          stuffReadbuff(eap->nextcmd);
+          stuffReadbuff((const char *)eap->nextcmd);
           eap->nextcmd = NULL;
         }
 
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 3bd8d580ab..a0981a42ce 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -2554,19 +2554,22 @@ void cmdline_paste_str(char_u *s, int literally)
   else
     while (*s != NUL) {
       cv = *s;
-      if (cv == Ctrl_V && s[1])
-        ++s;
-      if (has_mbyte)
-        c = mb_cptr2char_adv(&s);
-      else
+      if (cv == Ctrl_V && s[1]) {
+        s++;
+      }
+      if (has_mbyte) {
+        c = mb_cptr2char_adv((const char_u **)&s);
+      } else {
         c = *s++;
+      }
       if (cv == Ctrl_V || c == ESC || c == Ctrl_C
           || c == CAR || c == NL || c == Ctrl_L
 #ifdef UNIX
           || c == intr_char
 #endif
-          || (c == Ctrl_BSL && *s == Ctrl_N))
+          || (c == Ctrl_BSL && *s == Ctrl_N)) {
         stuffcharReadbuff(Ctrl_V);
+      }
       stuffcharReadbuff(c);
     }
 }
@@ -4636,7 +4639,7 @@ in_history (
 ///
 /// @return Any value from HistoryType enum, including HIST_INVALID. May not
 ///         return HIST_DEFAULT unless return_default is true.
-HistoryType get_histtype(const char_u *const name, const size_t len,
+HistoryType get_histtype(const char *const name, const size_t len,
                          const bool return_default)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -5029,7 +5032,7 @@ void ex_history(exarg_T *eap)
     while (ASCII_ISALPHA(*end)
            || vim_strchr((char_u *)":=@>/?", *end) != NULL)
       end++;
-    histype1 = get_histtype(arg, end - arg, false);
+    histype1 = get_histtype((const char *)arg, end - arg, false);
     if (histype1 == HIST_INVALID) {
       if (STRNICMP(arg, "all", end - arg) == 0) {
         histype1 = 0;
@@ -5288,18 +5291,18 @@ static int ex_window(void)
       cmdwin_result = Ctrl_C;
     /* Set the new command line from the cmdline buffer. */
     xfree(ccline.cmdbuff);
-    if (cmdwin_result == K_XF1 || cmdwin_result == K_XF2) {   /* :qa[!] typed */
-      char *p = (cmdwin_result == K_XF2) ? "qa" : "qa!";
+    if (cmdwin_result == K_XF1 || cmdwin_result == K_XF2) {  // :qa[!] typed
+      const char *p = (cmdwin_result == K_XF2) ? "qa" : "qa!";
 
       if (histtype == HIST_CMD) {
-        /* Execute the command directly. */
-        ccline.cmdbuff = vim_strsave((char_u *)p);
+        // Execute the command directly.
+        ccline.cmdbuff = (char_u *)xstrdup(p);
         cmdwin_result = CAR;
       } else {
-        /* First need to cancel what we were doing. */
+        // First need to cancel what we were doing.
         ccline.cmdbuff = NULL;
         stuffcharReadbuff(':');
-        stuffReadbuff((char_u *)p);
+        stuffReadbuff(p);
         stuffcharReadbuff(CAR);
       }
     } else if (cmdwin_result == K_XF2) {      /* :qa typed */
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 67ac9f9957..127efda65c 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -614,10 +614,12 @@ readfile (
       return FAIL;
     }
 #ifdef UNIX
-    /* Set swap file protection bits after creating it. */
+    // Set swap file protection bits after creating it.
     if (swap_mode > 0 && curbuf->b_ml.ml_mfp != NULL
-        && curbuf->b_ml.ml_mfp->mf_fname != NULL)
-      (void)os_setperm(curbuf->b_ml.ml_mfp->mf_fname, (long)swap_mode);
+        && curbuf->b_ml.ml_mfp->mf_fname != NULL) {
+      (void)os_setperm((const char *)curbuf->b_ml.ml_mfp->mf_fname,
+                       (long)swap_mode);
+    }
 #endif
   }
 
@@ -2870,9 +2872,9 @@ buf_write (
             xfree(backup);
             backup = NULL;
           } else {
-            /* set file protection same as original file, but
-             * strip s-bit */
-            (void)os_setperm(backup, perm & 0777);
+            // set file protection same as original file, but
+            // strip s-bit.
+            (void)os_setperm((const char *)backup, perm & 0777);
 
 #ifdef UNIX
             /*
@@ -2883,7 +2885,8 @@ buf_write (
              */
             if (file_info_new.stat.st_gid != file_info_old.stat.st_gid
                 && os_fchown(bfd, -1, file_info_old.stat.st_gid) != 0) {
-              os_setperm(backup, (perm & 0707) | ((perm & 07) << 3));
+              os_setperm((const char *)backup,
+                         (perm & 0707) | ((perm & 07) << 3));
             }
 # ifdef HAVE_SELINUX
             mch_copy_sec(fname, backup);
@@ -3037,8 +3040,8 @@ nobackup:
       && file_info_old.stat.st_uid == getuid()
       && vim_strchr(p_cpo, CPO_FWRITE) == NULL) {
     perm |= 0200;
-    (void)os_setperm(fname, perm);
-    made_writable = TRUE;
+    (void)os_setperm((const char *)fname, perm);
+    made_writable = true;
   }
 #endif
 
@@ -3402,8 +3405,9 @@ restore_backup:
         || file_info.stat.st_uid != file_info_old.stat.st_uid
         || file_info.stat.st_gid != file_info_old.stat.st_gid) {
       os_fchown(fd, file_info_old.stat.st_uid, file_info_old.stat.st_gid);
-      if (perm >= 0)            /* set permission again, may have changed */
-        (void)os_setperm(wfname, perm);
+      if (perm >= 0) {  // Set permission again, may have changed.
+        (void)os_setperm((const char *)wfname, perm);
+      }
     }
     buf_set_file_id(buf);
   } else if (!buf->file_id_valid) {
@@ -3421,8 +3425,9 @@ restore_backup:
   if (made_writable)
     perm &= ~0200;              /* reset 'w' bit for security reasons */
 #endif
-  if (perm >= 0)                /* set perm. of new file same as old file */
-    (void)os_setperm(wfname, perm);
+  if (perm >= 0) {  // Set perm. of new file same as old file.
+    (void)os_setperm((const char *)wfname, perm);
+  }
 #ifdef HAVE_ACL
   /* Probably need to set the ACL before changing the user (can't set the
    * ACL on a file the user doesn't own). */
@@ -3628,7 +3633,7 @@ restore_backup:
         close(empty_fd);
     }
     if (org != NULL) {
-      os_setperm((char_u *)org, os_getperm((const char *)fname) & 0777);
+      os_setperm(org, os_getperm((const char *)fname) & 0777);
       xfree(org);
     }
   }
@@ -4690,8 +4695,8 @@ int vim_rename(const char_u *from, const char_u *to)
     errmsg = _("E210: Error reading \"%s\"");
     to = from;
   }
-#ifndef UNIX        /* for Unix os_open() already set the permission */
-  os_setperm(to, perm);
+#ifndef UNIX  // For Unix os_open() already set the permission.
+  os_setperm((const char *)to, perm);
 #endif
 #ifdef HAVE_ACL
   mch_set_acl(to, acl);
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index b64f089b96..7143819e21 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -235,19 +235,18 @@ char_u *get_inserted(void)
   return get_buffcont(&redobuff, FALSE);
 }
 
-/*
- * Add string "s" after the current block of buffer "buf".
- * K_SPECIAL and CSI should have been escaped already.
- */
-static void 
-add_buff (
-    buffheader_T *buf,
-    char_u *s,
-    ssize_t slen                      // length of "s" or -1
-)
+/// Add string after the current block of the given buffer
+///
+/// K_SPECIAL and CSI should have been escaped already.
+///
+/// @param[out]  buf  Buffer to add to.
+/// @param[in]  s  String to add.
+/// @param[in]  slen  String length or -1 for NUL-terminated string.
+static void add_buff(buffheader_T *const buf, const char *const s,
+                     ptrdiff_t slen)
 {
   if (slen < 0) {
-    slen = (ssize_t)STRLEN(s);
+    slen = (ptrdiff_t)strlen(s);
   }
   if (slen == 0) {                              // don't add empty strings
     return;
@@ -292,9 +291,8 @@ add_buff (
  */
 static void add_num_buff(buffheader_T *buf, long n)
 {
-  char_u number[32];
-
-  sprintf((char *)number, "%" PRId64, (int64_t)n);
+  char number[32];
+  snprintf(number, sizeof(number), "%ld", n);
   add_buff(buf, number, -1L);
 }
 
@@ -304,27 +302,29 @@ static void add_num_buff(buffheader_T *buf, long n)
  */
 static void add_char_buff(buffheader_T *buf, int c)
 {
-  char_u bytes[MB_MAXBYTES + 1];
-  int len;
-  int i;
-  char_u temp[4];
+  char bytes[MB_MAXBYTES + 1];
 
-  if (IS_SPECIAL(c))
+  int len;
+  if (IS_SPECIAL(c)) {
     len = 1;
-  else
-    len = (*mb_char2bytes)(c, bytes);
-  for (i = 0; i < len; ++i) {
-    if (!IS_SPECIAL(c))
+  } else {
+    len = (*mb_char2bytes)(c, (char_u *)bytes);
+  }
+
+  for (int i = 0; i < len; i++) {
+    if (!IS_SPECIAL(c)) {
       c = bytes[i];
+    }
 
+    char temp[4];
     if (IS_SPECIAL(c) || c == K_SPECIAL || c == NUL) {
-      /* translate special key code into three byte sequence */
-      temp[0] = K_SPECIAL;
-      temp[1] = (char_u)K_SECOND(c);
-      temp[2] = (char_u)K_THIRD(c);
+      // Translate special key code into three byte sequence.
+      temp[0] = (char)K_SPECIAL;
+      temp[1] = (char)K_SECOND(c);
+      temp[2] = (char)K_THIRD(c);
       temp[3] = NUL;
     } else {
-      temp[0] = (char_u)c;
+      temp[0] = (char)c;
       temp[1] = NUL;
     }
     add_buff(buf, temp, -1L);
@@ -479,16 +479,14 @@ static int save_level = 0;
 
 void saveRedobuff(void)
 {
-  char_u      *s;
-
   if (save_level++ == 0) {
     save_redobuff = redobuff;
     redobuff.bh_first.b_next = NULL;
     save_old_redobuff = old_redobuff;
     old_redobuff.bh_first.b_next = NULL;
 
-    /* Make a copy, so that ":normal ." in a function works. */
-    s = get_buffcont(&save_redobuff, FALSE);
+    // Make a copy, so that ":normal ." in a function works.
+    char *const s = (char *)get_buffcont(&save_redobuff, false);
     if (s != NULL) {
       add_buff(&redobuff, s, -1L);
       xfree(s);
@@ -514,10 +512,11 @@ void restoreRedobuff(void)
  * Append "s" to the redo buffer.
  * K_SPECIAL and CSI should already have been escaped.
  */
-void AppendToRedobuff(char_u *s)
+void AppendToRedobuff(const char *s)
 {
-  if (!block_redo)
-    add_buff(&redobuff, s, -1L);
+  if (!block_redo) {
+    add_buff(&redobuff, (const char *)s, -1L);
+  }
 }
 
 /*
@@ -530,44 +529,47 @@ AppendToRedobuffLit (
     int len                    /* length of "str" or -1 for up to the NUL */
 )
 {
-  char_u      *s = str;
-  int c;
-  char_u      *start;
-
-  if (block_redo)
+  if (block_redo) {
     return;
+  }
 
-  while (len < 0 ? *s != NUL : s - str < len) {
-    /* Put a string of normal characters in the redo buffer (that's
-     * faster). */
-    start = s;
-    while (*s >= ' ' && *s < DEL && (len < 0 || s - str < len))
-      ++s;
-
-    /* Don't put '0' or '^' as last character, just in case a CTRL-D is
-     * typed next. */
-    if (*s == NUL && (s[-1] == '0' || s[-1] == '^'))
-      --s;
-    if (s > start)
+  const char *s = (const char *)str;
+  while (len < 0 ? *s != NUL : s - (const char *)str < len) {
+    // Put a string of normal characters in the redo buffer (that's
+    // faster).
+    const char *start = s;
+    while (*s >= ' ' && *s < DEL && (len < 0 || s - (const char *)str < len)) {
+      s++;
+    }
+
+    // Don't put '0' or '^' as last character, just in case a CTRL-D is
+    // typed next.
+    if (*s == NUL && (s[-1] == '0' || s[-1] == '^')) {
+      s--;
+    }
+    if (s > start) {
       add_buff(&redobuff, start, (long)(s - start));
+    }
 
-    if (*s == NUL || (len >= 0 && s - str >= len))
+    if (*s == NUL || (len >= 0 && s - (const char *)str >= len)) {
       break;
+    }
 
-    /* Handle a special or multibyte character. */
-    if (has_mbyte)
-      /* Handle composing chars separately. */
-      c = mb_cptr2char_adv(&s);
-    else
-      c = *s++;
-    if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^')))
+    // Handle a special or multibyte character.
+    // Composing chars separately are handled separately.
+    const int c = (has_mbyte
+                   ? mb_cptr2char_adv((const char_u **)&s)
+                   : (uint8_t)(*s++));
+    if (c < ' ' || c == DEL || (*s == NUL && (c == '0' || c == '^'))) {
       add_char_buff(&redobuff, Ctrl_V);
+    }
 
-    /* CTRL-V '0' must be inserted as CTRL-V 048 */
-    if (*s == NUL && c == '0')
-      add_buff(&redobuff, (char_u *)"048", 3L);
-    else
+    // CTRL-V '0' must be inserted as CTRL-V 048.
+    if (*s == NUL && c == '0') {
+      add_buff(&redobuff, "048", 3L);
+    } else {
       add_char_buff(&redobuff, c);
+    }
   }
 }
 
@@ -594,19 +596,19 @@ void AppendNumberToRedobuff(long n)
  * Append string "s" to the stuff buffer.
  * CSI and K_SPECIAL must already have been escaped.
  */
-void stuffReadbuff(char_u *s)
+void stuffReadbuff(const char *s)
 {
   add_buff(&readbuf1, s, -1L);
 }
 
 /// Append string "s" to the redo stuff buffer.
 /// @remark CSI and K_SPECIAL must already have been escaped.
-void stuffRedoReadbuff(char_u *s)
+void stuffRedoReadbuff(const char *s)
 {
   add_buff(&readbuf2, s, -1L);
 }
 
-void stuffReadbuffLen(char_u *s, long len)
+void stuffReadbuffLen(const char *s, long len)
 {
   add_buff(&readbuf1, s, len);
 }
@@ -616,19 +618,18 @@ void stuffReadbuffLen(char_u *s, long len)
  * escaping other K_SPECIAL and CSI bytes.
  * Change CR, LF and ESC into a space.
  */
-void stuffReadbuffSpec(char_u *s)
+void stuffReadbuffSpec(const char *s)
 {
-  int c;
-
   while (*s != NUL) {
-    if (*s == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
-      /* Insert special key literally. */
-      stuffReadbuffLen(s, 3L);
+    if ((uint8_t)(*s) == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
+      // Insert special key literally.
+      stuffReadbuffLen(s, 3);
       s += 3;
     } else {
-      c = mb_ptr2char_adv(&s);
-      if (c == CAR || c == NL || c == ESC)
+      int c = mb_ptr2char_adv((const char_u **)&s);
+      if (c == CAR || c == NL || c == ESC) {
         c = ' ';
+      }
       stuffcharReadbuff(c);
     }
   }
@@ -747,8 +748,8 @@ int start_redo(long count, int old_redo)
 
   /* copy the buffer name, if present */
   if (c == '"') {
-    add_buff(&readbuf2, (char_u *)"\"", 1L);
-    c = read_redo(FALSE, old_redo);
+    add_buff(&readbuf2, "\"", 1L);
+    c = read_redo(false, old_redo);
 
     /* if a numbered buffer is used, increment the number */
     if (c >= '1' && c < '9')
@@ -1091,21 +1092,19 @@ static void gotchars(char_u *chars, size_t len)
 {
   char_u      *s = chars;
   int c;
-  char_u buf[2];
 
   // remember how many chars were last recorded
   if (Recording) {
     last_recorded_len += len;
   }
 
-  buf[1] = NUL;
   while (len--) {
     // Handle one byte at a time; no translation to be done.
     c = *s++;
     updatescript(c);
 
     if (Recording) {
-      buf[0] = (char_u)c;
+      char buf[2] = { (char)c, NUL };
       add_buff(&recordbuff, buf, 1L);
     }
   }
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index d87407f099..c15287aa38 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -1199,6 +1199,7 @@ EXTERN char_u e_dirnotf[] INIT(= N_(
     "E919: Directory not found in '%s': \"%s\""));
 EXTERN char_u e_unsupportedoption[] INIT(= N_("E519: Option not supported"));
 EXTERN char_u e_fnametoolong[] INIT(= N_("E856: Filename too long"));
+EXTERN char_u e_float_as_string[] INIT(= N_("E806: using Float as a String"));
 
 
 EXTERN char top_bot_msg[] INIT(= N_("search hit TOP, continuing at BOTTOM"));
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 621fa6fefc..d96848754c 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -625,7 +625,7 @@ static int utf_safe_read_char_adv(const char_u **s, size_t *n)
  * Get character at **pp and advance *pp to the next character.
  * Note: composing characters are skipped!
  */
-int mb_ptr2char_adv(char_u **pp)
+int mb_ptr2char_adv(const char_u **const pp)
 {
   int c;
 
@@ -638,7 +638,7 @@ int mb_ptr2char_adv(char_u **pp)
  * Get character at **pp and advance *pp to the next character.
  * Note: composing characters are returned as separate characters.
  */
-int mb_cptr2char_adv(char_u **pp)
+int mb_cptr2char_adv(const char_u **pp)
 {
   int c;
 
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 6ef929120e..d4919dc3b6 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -1155,7 +1155,7 @@ static void normal_check_stuff_buffer(NormalState *s)
 
     if (need_start_insertmode && goto_im() && !VIsual_active) {
       need_start_insertmode = false;
-      stuffReadbuff((uint8_t *)"i");  // start insert mode next
+      stuffReadbuff("i");  // start insert mode next
       // skip the fileinfo message now, because it would be shown
       // after insert mode finishes!
       need_fileinfo = false;
@@ -1469,8 +1469,9 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
          * If 'cpoptions' does not contain 'r', insert the search
          * pattern to really repeat the same command.
          */
-        if (vim_strchr(p_cpo, CPO_REDO) == NULL)
+        if (vim_strchr(p_cpo, CPO_REDO) == NULL) {
           AppendToRedobuffLit(cap->searchbuf, -1);
+        }
         AppendToRedobuff(NL_STR);
       } else if (cap->cmdchar == ':') {
         /* do_cmdline() has stored the first typed line in
@@ -1853,10 +1854,11 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
       break;
 
     case OP_FILTER:
-      if (vim_strchr(p_cpo, CPO_FILTER) != NULL)
-        AppendToRedobuff((char_u *)"!\r");          /* use any last used !cmd */
-      else
-        bangredo = true;            /* do_bang() will put cmd in redo buffer */
+      if (vim_strchr(p_cpo, CPO_FILTER) != NULL) {
+        AppendToRedobuff("!\r");  // Use any last used !cmd.
+      } else {
+        bangredo = true;  // do_bang() will put cmd in redo buffer.
+      }
 
     case OP_INDENT:
     case OP_COLON:
@@ -2026,43 +2028,44 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
 static void op_colon(oparg_T *oap)
 {
   stuffcharReadbuff(':');
-  if (oap->is_VIsual)
-    stuffReadbuff((char_u *)"'<,'>");
-  else {
-    /*
-     * Make the range look nice, so it can be repeated.
-     */
-    if (oap->start.lnum == curwin->w_cursor.lnum)
+  if (oap->is_VIsual) {
+    stuffReadbuff("'<,'>");
+  } else {
+    // Make the range look nice, so it can be repeated.
+    if (oap->start.lnum == curwin->w_cursor.lnum) {
       stuffcharReadbuff('.');
-    else
+    } else {
       stuffnumReadbuff((long)oap->start.lnum);
+    }
     if (oap->end.lnum != oap->start.lnum) {
       stuffcharReadbuff(',');
-      if (oap->end.lnum == curwin->w_cursor.lnum)
+      if (oap->end.lnum == curwin->w_cursor.lnum) {
         stuffcharReadbuff('.');
-      else if (oap->end.lnum == curbuf->b_ml.ml_line_count)
+      } else if (oap->end.lnum == curbuf->b_ml.ml_line_count) {
         stuffcharReadbuff('$');
-      else if (oap->start.lnum == curwin->w_cursor.lnum) {
-        stuffReadbuff((char_u *)".+");
+      } else if (oap->start.lnum == curwin->w_cursor.lnum) {
+        stuffReadbuff(".+");
         stuffnumReadbuff(oap->line_count - 1);
-      } else
+      } else {
         stuffnumReadbuff((long)oap->end.lnum);
+      }
     }
   }
-  if (oap->op_type != OP_COLON)
-    stuffReadbuff((char_u *)"!");
+  if (oap->op_type != OP_COLON) {
+    stuffReadbuff("!");
+  }
   if (oap->op_type == OP_INDENT) {
-    stuffReadbuff(get_equalprg());
-    stuffReadbuff((char_u *)"\n");
+    stuffReadbuff((const char *)get_equalprg());
+    stuffReadbuff("\n");
   } else if (oap->op_type == OP_FORMAT) {
     if (*curbuf->b_p_fp != NUL) {
-      stuffReadbuff(curbuf->b_p_fp);
+      stuffReadbuff((const char *)curbuf->b_p_fp);
     } else if (*p_fp != NUL) {
-      stuffReadbuff(p_fp);
+      stuffReadbuff((const char *)p_fp);
     } else {
-      stuffReadbuff((char_u *)"fmt");
+      stuffReadbuff("fmt");
     }
-    stuffReadbuff((char_u *)"\n']");
+    stuffReadbuff("\n']");
   }
 
   /*
@@ -2304,7 +2307,7 @@ do_mouse (
       if (VIsual_active) {
         if (VIsual_select) {
           stuffcharReadbuff(Ctrl_G);
-          stuffReadbuff((char_u *)"\"+p");
+          stuffReadbuff("\"+p");
         } else {
           stuffcharReadbuff('y');
           stuffcharReadbuff(K_MIDDLEMOUSE);
@@ -4476,7 +4479,7 @@ static void nv_colon(cmdarg_T *cap)
       /* translate "count:" into ":.,.+(count - 1)" */
       stuffcharReadbuff('.');
       if (cap->count0 > 1) {
-        stuffReadbuff((char_u *)",.+");
+        stuffReadbuff(",.+");
         stuffnumReadbuff(cap->count0 - 1L);
       }
     }
@@ -6156,17 +6159,15 @@ static void nv_abbrev(cmdarg_T *cap)
  */
 static void nv_optrans(cmdarg_T *cap)
 {
-  static char_u *(ar[8]) = {(char_u *)"dl", (char_u *)"dh",
-                            (char_u *)"d$", (char_u *)"c$",
-                            (char_u *)"cl", (char_u *)"cc",
-                            (char_u *)"yy", (char_u *)":s\r"};
-  static char_u *str = (char_u *)"xXDCsSY&";
+  static const char *(ar[]) = { "dl", "dh", "d$", "c$", "cl", "cc", "yy",
+                                ":s\r" };
+  static const char *str = "xXDCsSY&";
 
   if (!checkclearopq(cap->oap)) {
     if (cap->count0) {
       stuffnumReadbuff(cap->count0);
     }
-    stuffReadbuff(ar[(int)(vim_strchr(str, cap->cmdchar) - str)]);
+    stuffReadbuff(ar[strchr(str, (char)cap->cmdchar) - str]);
   }
   cap->opcount = 0;
 }
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index fd1e2d20f2..68ef27222c 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -1109,7 +1109,6 @@ int insert_reg(
 )
 {
   int retval = OK;
-  char_u      *arg;
   int allocated;
 
   /*
@@ -1125,21 +1124,24 @@ int insert_reg(
   if (regname != NUL && !valid_yank_reg(regname, false))
     return FAIL;
 
-  if (regname == '.')                   /* insert last inserted text */
-    retval = stuff_inserted(NUL, 1L, TRUE);
-  else if (get_spec_reg(regname, &arg, &allocated, TRUE)) {
-    if (arg == NULL)
+  char_u *arg;
+  if (regname == '.') {  // Insert last inserted text.
+    retval = stuff_inserted(NUL, 1L, true);
+  } else if (get_spec_reg(regname, &arg, &allocated, true)) {
+    if (arg == NULL) {
       return FAIL;
-    stuffescaped(arg, literally);
-    if (allocated)
+    }
+    stuffescaped((const char *)arg, literally);
+    if (allocated) {
       xfree(arg);
-  } else {                            /* name or number register */
+    }
+  } else {  // Name or number register.
     yankreg_T *reg = get_yank_register(regname, YREG_PASTE);
     if (reg->y_array == NULL) {
       retval = FAIL;
     } else {
       for (size_t i = 0; i < reg->y_size; i++) {
-        stuffescaped(reg->y_array[i], literally);
+        stuffescaped((const char *)reg->y_array[i], literally);
         // Insert a newline between lines and after last line if
         // y_type is kMTLineWise.
         if (reg->y_type == kMTLineWise || i < reg->y_size - 1) {
@@ -1156,29 +1158,29 @@ int insert_reg(
  * Stuff a string into the typeahead buffer, such that edit() will insert it
  * literally ("literally" TRUE) or interpret is as typed characters.
  */
-static void stuffescaped(char_u *arg, int literally)
+static void stuffescaped(const char *arg, int literally)
 {
-  int c;
-  char_u      *start;
-
   while (*arg != NUL) {
-    /* Stuff a sequence of normal ASCII characters, that's fast.  Also
-     * stuff K_SPECIAL to get the effect of a special key when "literally"
-     * is TRUE. */
-    start = arg;
-    while ((*arg >= ' ' && *arg < DEL) || (*arg == K_SPECIAL && !literally))
-      ++arg;
-    if (arg > start)
+    // Stuff a sequence of normal ASCII characters, that's fast.  Also
+    // stuff K_SPECIAL to get the effect of a special key when "literally"
+    // is TRUE.
+    const char *const start = arg;
+    while ((*arg >= ' ' && *arg < DEL) || ((uint8_t)(*arg) == K_SPECIAL
+                                           && !literally)) {
+      arg++;
+    }
+    if (arg > start) {
       stuffReadbuffLen(start, (long)(arg - start));
+    }
 
     /* stuff a single special character */
     if (*arg != NUL) {
-      if (has_mbyte)
-        c = mb_cptr2char_adv(&arg);
-      else
-        c = *arg++;
-      if (literally && ((c < ' ' && c != TAB) || c == DEL))
+      const int c = (has_mbyte
+                     ? mb_cptr2char_adv((const char_u **)&arg)
+                     : (uint8_t)(*arg++));
+      if (literally && ((c < ' ' && c != TAB) || c == DEL)) {
         stuffcharReadbuff(Ctrl_V);
+      }
       stuffcharReadbuff(c);
     }
   }
@@ -2663,7 +2665,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           // back to the previous line in the case of 'noautoindent' and
           // 'backspace' includes "eol". So we insert a dummy space for Ctrl_U
           // to consume.
-          stuffReadbuff((char_u *)"\n ");
+          stuffReadbuff("\n ");
           stuffcharReadbuff(Ctrl_U);
         }
       }
@@ -2675,7 +2677,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
     // character.  Simulate it with motion commands after the insert.
     if (flags & PUT_CURSEND) {
       if (flags & PUT_LINE) {
-        stuffReadbuff((char_u *)"j0");
+        stuffReadbuff("j0");
       } else {
         // Avoid ringing the bell from attempting to move into the space after
         // the current line. We can stuff the readbuffer with "l" if:
@@ -2705,7 +2707,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         }
       }
     } else if (flags & PUT_LINE) {
-      stuffReadbuff((char_u *)"g'[");
+      stuffReadbuff("g'[");
     }
 
     // So the 'u' command restores cursor position after ".p, save the cursor
@@ -4981,7 +4983,7 @@ void write_reg_contents(int name, const char_u *str, ssize_t len,
   write_reg_contents_ex(name, str, len, must_append, kMTUnknown, 0L);
 }
 
-void write_reg_contents_lst(int name, char_u **strings, int maxlen,
+void write_reg_contents_lst(int name, char_u **strings,
                             bool must_append, MotionType yank_type,
                             colnr_T block_len)
 {
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 1881b329ec..8a80c46cf2 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -3419,15 +3419,18 @@ static char_u *set_chars_option(char_u **varp)
             && p[len] == ':'
             && p[len + 1] != NUL) {
           s = p + len + 1;
-          c1 = mb_ptr2char_adv(&s);
-          if (mb_char2cells(c1) > 1)
+          c1 = mb_ptr2char_adv((const char_u **)&s);
+          if (mb_char2cells(c1) > 1) {
             continue;
+          }
           if (tab[i].cp == &lcs_tab2) {
-            if (*s == NUL)
+            if (*s == NUL) {
               continue;
-            c2 = mb_ptr2char_adv(&s);
-            if (mb_char2cells(c2) > 1)
+            }
+            c2 = mb_ptr2char_adv((const char_u **)&s);
+            if (mb_char2cells(c2) > 1) {
               continue;
+            }
           }
           if (*s == ',' || *s == NUL) {
             if (round) {
@@ -6887,8 +6890,8 @@ void set_fileformat(int eol_style, int opt_flags)
   need_maketitle = true;  // Set window title later.
 }
 
-/// Skip to next part of an option argument: Skip space and comma.
-char_u *skip_to_option_part(char_u *p)
+/// Skip to next part of an option argument: skip space and comma
+char_u *skip_to_option_part(const char_u *p)
 {
   if (*p == ',') {
     p++;
@@ -6896,7 +6899,7 @@ char_u *skip_to_option_part(char_u *p)
   while (*p == ' ') {
     p++;
   }
-  return p;
+  return (char_u *)p;
 }
 
 /// Isolate one part of a string option separated by `sep_chars`.
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index 0372bc8a8c..3833a43f5f 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -622,11 +622,11 @@ int32_t os_getperm(const char *name)
 /// Set the permission of a file.
 ///
 /// @return `OK` for success, `FAIL` for failure.
-int os_setperm(const char_u *name, int perm)
+int os_setperm(const char *const name, int perm)
   FUNC_ATTR_NONNULL_ALL
 {
   int r;
-  RUN_UV_FS_FUNC(r, uv_fs_chmod, (const char *)name, perm, NULL);
+  RUN_UV_FS_FUNC(r, uv_fs_chmod, name, perm, NULL);
   return (r == kLibuvSuccess ? OK : FAIL);
 }
 
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index 9c6f02f778..9baa53d2a2 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -2221,10 +2221,11 @@ collection:
               if (*regparse == '[')
                 endc = get_coll_element(&regparse);
               if (endc == 0) {
-                if (has_mbyte)
-                  endc = mb_ptr2char_adv(&regparse);
-                else
+                if (has_mbyte) {
+                  endc = mb_ptr2char_adv((const char_u **)&regparse);
+                } else {
                   endc = *regparse++;
+                }
               }
 
               /* Handle \o40, \x20 and \u20AC style sequences */
@@ -6271,8 +6272,8 @@ static int cstrncmp(char_u *s1, char_u *s2, int *n)
     str2 = s2;
     c1 = c2 = 0;
     while ((int)(str1 - s1) < *n) {
-      c1 = mb_ptr2char_adv(&str1);
-      c2 = mb_ptr2char_adv(&str2);
+      c1 = mb_ptr2char_adv((const char_u **)&str1);
+      c2 = mb_ptr2char_adv((const char_u **)&str2);
 
       /* decompose the character if necessary, into 'base' characters
        * because I don't care about Arabic, I will hard-code the Hebrew
@@ -6586,7 +6587,6 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
       if (expr != NULL) {
         typval_T argv[2];
         int dummy;
-        char_u buf[NUMBUFLEN];
         typval_T rettv;
         staticList10_T matchList;
 
@@ -6616,7 +6616,8 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
             clear_submatch_list(&matchList);
           }
         }
-        eval_result = get_tv_string_buf_chk(&rettv, buf);
+        char buf[NUMBUFLEN];
+        eval_result = (char_u *)tv_get_string_buf_chk(&rettv, buf);
         if (eval_result != NULL) {
           eval_result = vim_strsave(eval_result);
         }
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 505d04ed56..cf460adb82 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -3141,7 +3141,7 @@ win_line (
 
             p_extra = extra;
             c = *p_extra;
-            mb_c = mb_ptr2char_adv(&p_extra);
+            mb_c = mb_ptr2char_adv((const char_u **)&p_extra);
             mb_utf8 = (c >= 0x80);
             n_extra = (int)STRLEN(p_extra);
             c_extra = NUL;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 84bee9b97f..d4f49bffb2 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -2309,10 +2309,11 @@ int captype(char_u *word, char_u *end)
   for (p = word; !spell_iswordp_nmw(p, curwin); mb_ptr_adv(p))
     if (end == NULL ? *p == NUL : p >= end)
       return 0;             // only non-word characters, illegal word
-  if (has_mbyte)
-    c = mb_ptr2char_adv(&p);
-  else
+  if (has_mbyte) {
+    c = mb_ptr2char_adv((const char_u **)&p);
+  } else {
     c = *p++;
+  }
   firstcap = allcap = SPELL_ISUPPER(c);
 
   // Need to check all letters to find a word with mixed upper/lower.
@@ -2607,14 +2608,15 @@ static bool spell_iswordp(char_u *p, win_T *wp)
 
 // Returns true if "p" points to a word character.
 // Unlike spell_iswordp() this doesn't check for "midword" characters.
-bool spell_iswordp_nmw(char_u *p, win_T *wp)
+bool spell_iswordp_nmw(const char_u *p, win_T *wp)
 {
   int c;
 
   if (has_mbyte) {
     c = mb_ptr2char(p);
-    if (c > 255)
+    if (c > 255) {
       return spell_mb_isword_class(mb_get_class(p), wp);
+    }
     return spelltab.st_isw[c];
   }
   return spelltab.st_isw[*p];
@@ -2675,7 +2677,7 @@ int spell_casefold(char_u *str, int len, char_u *buf, int buflen)
         buf[outi] = NUL;
         return FAIL;
       }
-      c = mb_cptr2char_adv(&p);
+      c = mb_cptr2char_adv((const char_u **)&p);
       outi += mb_char2bytes(SPELL_TOFOLD(c), buf + outi);
     }
     buf[outi] = NUL;
@@ -2937,7 +2939,7 @@ void spell_suggest(int count)
 
     // For redo we use a change-word command.
     ResetRedobuff();
-    AppendToRedobuff((char_u *)"ciw");
+    AppendToRedobuff("ciw");
     AppendToRedobuffLit(p + c,
         stp->st_wordlen + sug.su_badlen - stp->st_orglen);
     AppendCharToRedobuff(ESC);
@@ -3406,17 +3408,19 @@ void onecap_copy(char_u *word, char_u *wcopy, bool upper)
   int l;
 
   p = word;
-  if (has_mbyte)
-    c = mb_cptr2char_adv(&p);
-  else
+  if (has_mbyte) {
+    c = mb_cptr2char_adv((const char_u **)&p);
+  } else {
     c = *p++;
-  if (upper)
+  }
+  if (upper) {
     c = SPELL_TOUPPER(c);
-  else
+  } else {
     c = SPELL_TOFOLD(c);
-  if (has_mbyte)
+  }
+  if (has_mbyte) {
     l = mb_char2bytes(c, wcopy);
-  else {
+  } else {
     l = 1;
     wcopy[0] = c;
   }
@@ -3433,10 +3437,11 @@ static void allcap_copy(char_u *word, char_u *wcopy)
 
   d = wcopy;
   for (s = word; *s != NUL; ) {
-    if (has_mbyte)
-      c = mb_cptr2char_adv(&s);
-    else
+    if (has_mbyte) {
+      c = mb_cptr2char_adv((const char_u **)&s);
+    } else {
       c = *s++;
+    }
 
     if (c == 0xdf) {
       c = 'S';
@@ -5938,12 +5943,12 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
     // The sl_sal_first[] table contains the translation for chars up to
     // 255, sl_sal the rest.
     for (s = inword; *s != NUL; ) {
-      c = mb_cptr2char_adv(&s);
-      if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c))
+      c = mb_cptr2char_adv((const char_u **)&s);
+      if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c)) {
         c = ' ';
-      else if (c < 256)
+      } else if (c < 256) {
         c = slang->sl_sal_first[c];
-      else {
+      } else {
         ip = ((int **)slang->sl_sal.ga_data)[c & 0xff];
         if (ip == NULL)                 // empty list, can't match
           c = NUL;
@@ -6228,9 +6233,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
   int word[MAXWLEN];
   int wres[MAXWLEN];
   int l;
-  char_u      *s;
   int         *ws;
-  char_u      *t;
   int         *pf;
   int i, j, z;
   int reslen;
@@ -6250,9 +6253,9 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
   // Remove accents, if wanted.  We actually remove all non-word characters.
   // But keep white space.
   wordlen = 0;
-  for (s = inword; *s != NUL; ) {
-    t = s;
-    c = mb_cptr2char_adv(&s);
+  for (const char_u *s = inword; *s != NUL; ) {
+    const char_u *t = s;
+    c = mb_cptr2char_adv((const char_u **)&s);
     if (slang->sl_rem_accents) {
       if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c)) {
         if (did_white)
@@ -6261,8 +6264,9 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
         did_white = true;
       } else {
         did_white = false;
-        if (!spell_iswordp_nmw(t, curwin))
+        if (!spell_iswordp_nmw(t, curwin)) {
           continue;
+        }
       }
     }
     word[wordlen++] = c;
@@ -6309,7 +6313,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
             continue;
           ++k;
         }
-        s = smp[n].sm_rules;
+        char_u *s = smp[n].sm_rules;
         pri = 5;            // default priority
 
         p0 = *s;
@@ -6708,25 +6712,30 @@ soundalike_score (
 // support multi-byte characters.
 static int spell_edit_score(slang_T *slang, char_u *badword, char_u *goodword)
 {
-  int         *cnt;
-  int badlen, goodlen;                  // lengths including NUL
+  int *cnt;
   int j, i;
   int t;
   int bc, gc;
   int pbc, pgc;
-  char_u      *p;
   int wbadword[MAXWLEN];
   int wgoodword[MAXWLEN];
   const bool l_has_mbyte = has_mbyte;
 
+  // Lengths with NUL.
+  int badlen;
+  int goodlen;
   if (l_has_mbyte) {
     // Get the characters from the multi-byte strings and put them in an
     // int array for easy access.
-    for (p = badword, badlen = 0; *p != NUL; )
+    badlen = 0;
+    for (const char_u *p = badword; *p != NUL; ) {
       wbadword[badlen++] = mb_cptr2char_adv(&p);
+    }
     wbadword[badlen++] = 0;
-    for (p = goodword, goodlen = 0; *p != NUL; )
+    goodlen = 0;
+    for (const char_u *p = goodword; *p != NUL; ) {
       wgoodword[goodlen++] = mb_cptr2char_adv(&p);
+    }
     wgoodword[goodlen++] = 0;
   } else {
     badlen = (int)STRLEN(badword) + 1;
@@ -6960,19 +6969,20 @@ static int spell_edit_score_limit_w(slang_T *slang, char_u *badword, char_u *goo
   int score_off;
   int minscore;
   int round;
-  char_u          *p;
   int wbadword[MAXWLEN];
   int wgoodword[MAXWLEN];
 
   // Get the characters from the multi-byte strings and put them in an
   // int array for easy access.
   bi = 0;
-  for (p = badword; *p != NUL; )
+  for (const char_u *p = badword; *p != NUL; ) {
     wbadword[bi++] = mb_cptr2char_adv(&p);
+  }
   wbadword[bi++] = 0;
   gi = 0;
-  for (p = goodword; *p != NUL; )
+  for (const char_u *p = goodword; *p != NUL; ) {
     wgoodword[gi++] = mb_cptr2char_adv(&p);
+  }
   wgoodword[gi++] = 0;
 
   // The idea is to go from start to end over the words.  So long as
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 6ba2801203..4d7ff558ad 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -1435,7 +1435,7 @@ static int set_sofo(slang_T *lp, char_u *from, char_u *to)
     // First count the number of items for each list.  Temporarily use
     // sl_sal_first[] for this.
     for (p = from, s = to; *p != NUL && *s != NUL; ) {
-      c = mb_cptr2char_adv(&p);
+      c = mb_cptr2char_adv((const char_u **)&p);
       mb_cptr_adv(s);
       if (c >= 256)
         ++lp->sl_sal_first[c & 0xff];
@@ -1455,8 +1455,8 @@ static int set_sofo(slang_T *lp, char_u *from, char_u *to)
     // list.
     memset(lp->sl_sal_first, 0, sizeof(salfirst_T) * 256);
     for (p = from, s = to; *p != NUL && *s != NUL; ) {
-      c = mb_cptr2char_adv(&p);
-      i = mb_cptr2char_adv(&s);
+      c = mb_cptr2char_adv((const char_u **)&p);
+      i = mb_cptr2char_adv((const char_u **)&s);
       if (c >= 256) {
         // Append the from-to chars at the end of the list with
         // the low byte.
@@ -1542,8 +1542,9 @@ static int *mb_str2wide(char_u *s)
   int i = 0;
 
   int *res = xmalloc((mb_charlen(s) + 1) * sizeof(int));
-  for (char_u *p = s; *p != NUL; )
-    res[i++] = mb_ptr2char_adv(&p);
+  for (char_u *p = s; *p != NUL; ) {
+    res[i++] = mb_ptr2char_adv((const char_u **)&p);
+  }
   res[i] = NUL;
 
   return res;
@@ -2486,13 +2487,14 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 
           // Check that every character appears only once.
           for (p = items[1]; *p != NUL; ) {
-            c = mb_ptr2char_adv(&p);
+            c = mb_ptr2char_adv((const char_u **)&p);
             if ((!GA_EMPTY(&spin->si_map)
                  && vim_strchr(spin->si_map.ga_data, c)
                  != NULL)
-                || vim_strchr(p, c) != NULL)
+                || vim_strchr(p, c) != NULL) {
               smsg(_("Duplicate character in MAP in %s line %d"),
                    fname, lnum);
+            }
           }
 
           // We simply concatenate all the MAP strings, separated by
@@ -2717,12 +2719,12 @@ static unsigned get_affitem(int flagtype, char_u **pp)
     }
     res = getdigits_int(pp);
   } else {
-    res = mb_ptr2char_adv(pp);
+    res = mb_ptr2char_adv((const char_u **)pp);
     if (flagtype == AFT_LONG || (flagtype == AFT_CAPLONG
                                  && res >= 'A' && res <= 'Z')) {
       if (**pp == NUL)
         return 0;
-      res = mb_ptr2char_adv(pp) + (res << 16);
+      res = mb_ptr2char_adv((const char_u **)pp) + (res << 16);
     }
   }
   return res;
@@ -2823,12 +2825,14 @@ static bool flag_in_afflist(int flagtype, char_u *afflist, unsigned flag)
   case AFT_CAPLONG:
   case AFT_LONG:
     for (p = afflist; *p != NUL; ) {
-      n = mb_ptr2char_adv(&p);
+      n = mb_ptr2char_adv((const char_u **)&p);
       if ((flagtype == AFT_LONG || (n >= 'A' && n <= 'Z'))
-          && *p != NUL)
-        n = mb_ptr2char_adv(&p) + (n << 16);
-      if (n == flag)
+          && *p != NUL) {
+        n = mb_ptr2char_adv((const char_u **)&p) + (n << 16);
+      }
+      if (n == flag) {
         return true;
+      }
     }
     break;
 
@@ -5436,9 +5440,10 @@ static void init_spellfile(void)
         fname = LANGP_ENTRY(curwin->w_s->b_langp, 0)
                 ->lp_slang->sl_fname;
         vim_snprintf((char *)buf + l, MAXPATHL - l, ".%s.add",
-            fname != NULL
-            && strstr((char *)path_tail(fname), ".ascii.") != NULL
-            ? (char_u *)"ascii" : spell_enc());
+                     ((fname != NULL
+                       && strstr((char *)path_tail(fname), ".ascii.") != NULL)
+                      ? "ascii"
+                      : (const char *)spell_enc()));
         set_option_value("spellfile", 0L, (const char *)buf, OPT_LOCAL);
         break;
       }
@@ -5465,9 +5470,9 @@ static int set_spell_chartab(char_u *fol, char_u *low, char_u *upp)
       EMSG(_(e_affform));
       return FAIL;
     }
-    f = mb_ptr2char_adv(&pf);
-    l = mb_ptr2char_adv(&pl);
-    u = mb_ptr2char_adv(&pu);
+    f = mb_ptr2char_adv((const char_u **)&pf);
+    l = mb_ptr2char_adv((const char_u **)&pl);
+    u = mb_ptr2char_adv((const char_u **)&pu);
     // Every character that appears is a word character.
     if (f < 256)
       new_st.st_isw[f] = true;
@@ -5532,7 +5537,7 @@ set_spell_charflags (
     }
 
     if (*p != NUL) {
-      c = mb_ptr2char_adv(&p);
+      c = mb_ptr2char_adv((const char_u **)&p);
       new_st.st_fold[i + 128] = c;
       if (i + 128 != c && new_st.st_isu[i + 128] && c < 256)
         new_st.st_upper[c] = i + 128;
@@ -5619,12 +5624,13 @@ static void set_map_str(slang_T *lp, char_u *map)
   // "aaa/bbb/ccc/".  Fill sl_map_array[c] with the character before c and
   // before the same slash.  For characters above 255 sl_map_hash is used.
   for (p = map; *p != NUL; ) {
-    c = mb_cptr2char_adv(&p);
-    if (c == '/')
+    c = mb_cptr2char_adv((const char_u **)&p);
+    if (c == '/') {
       headc = 0;
-    else {
-      if (headc == 0)
+    } else {
+      if (headc == 0) {
         headc = c;
+      }
 
       // Characters above 255 don't fit in sl_map_array[], put them in
       // the hash table.  Each entry is the char, a NUL the headchar and
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index e20979c307..5dcffe00e0 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -598,22 +598,21 @@ static varnumber_T tv_nr(typval_T *tvs, int *idxp)
 ///                      free "*tofree".
 ///
 /// @return String value or NULL in case of error.
-static char *tv_str(typval_T *tvs, int *idxp, char ** const tofree)
+static const char *tv_str(typval_T *tvs, int *idxp, char **const tofree)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
   int idx = *idxp - 1;
-  char *s = NULL;
+  const char *s = NULL;
 
   if (tvs[idx].v_type == VAR_UNKNOWN) {
     EMSG(_(e_printf));
   } else {
     (*idxp)++;
     if (tvs[idx].v_type == VAR_STRING || tvs[idx].v_type == VAR_NUMBER) {
-      s = (char *)get_tv_string_chk(&tvs[idx]);
+      s = tv_get_string_chk(&tvs[idx]);
       *tofree = NULL;
     } else {
-      s = encode_tv2echo(&tvs[idx], NULL);
-      *tofree = s;
+      s = *tofree = encode_tv2echo(&tvs[idx], NULL);
     }
   }
   return s;
@@ -953,7 +952,7 @@ int vim_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap,
             case 's':
             case 'S':
               str_arg = tvs ? tv_str(tvs, &arg_idx, &tofree)
-                            : va_arg(ap, char *);
+                            : va_arg(ap, const char *);
               if (!str_arg) {
                 str_arg = "[NULL]";
                 str_arg_l = 6;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 010ef2c8fa..4d4e8d9bb9 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -1140,7 +1140,7 @@ void u_write_undo(const char *const name, const bool forceit, buf_T *const buf,
     EMSG2(_(e_not_open), file_name);
     goto theend;
   }
-  (void)os_setperm((char_u *)file_name, perm);
+  (void)os_setperm(file_name, perm);
   if (p_verbose > 0) {
     verbose_enter();
     smsg(_("Writing undo file: %s"), file_name);
@@ -1165,7 +1165,7 @@ void u_write_undo(const char *const name, const bool forceit, buf_T *const buf,
       && os_fileinfo(file_name, &file_info_new)
       && file_info_old.stat.st_gid != file_info_new.stat.st_gid
       && os_fchown(fd, (uv_uid_t)-1, (uv_gid_t)file_info_old.stat.st_gid)) {
-    os_setperm((char_u *)file_name, (perm & 0707) | ((perm & 07) << 3));
+    os_setperm(file_name, (perm & 0707) | ((perm & 07) << 3));
   }
 # ifdef HAVE_SELINUX
   if (buf->b_ffname != NULL)
diff --git a/test/functional/eval/input_spec.lua b/test/functional/eval/input_spec.lua
new file mode 100644
index 0000000000..393fc10175
--- /dev/null
+++ b/test/functional/eval/input_spec.lua
@@ -0,0 +1,38 @@
+local helpers = require('test.functional.helpers')(after_each)
+local Screen = require('test.functional.ui.screen')
+
+local feed = helpers.feed
+local clear = helpers.clear
+local command = helpers.command
+
+local screen
+
+before_each(function()
+  clear()
+  screen = Screen.new(25, 5)
+  screen:attach()
+end)
+
+describe('input()', function()
+  it('works correctly with multiline prompts', function()
+    feed([[:call input("Test\nFoo")<CR>]])
+    screen:expect([[
+      {1:~                        }|
+      {1:~                        }|
+      {1:~                        }|
+      Test                     |
+      Foo^                      |
+    ]], {{bold=true, foreground=Screen.colors.Blue}})
+  end)
+  it('works correctly with multiline prompts and :echohl', function()
+    command('hi Test ctermfg=Red guifg=Red term=bold')
+    feed([[:echohl Test | call input("Test\nFoo")<CR>]])
+    screen:expect([[
+      {1:~                        }|
+      {1:~                        }|
+      {1:~                        }|
+      {2:Test}                     |
+      {2:Foo}^                      |
+    ]], {{bold=true, foreground=Screen.colors.Blue}, {foreground=Screen.colors.Red}})
+  end)
+end)
diff --git a/test/functional/eval/match_functions_spec.lua b/test/functional/eval/match_functions_spec.lua
index f6bad59c66..3150d89f62 100644
--- a/test/functional/eval/match_functions_spec.lua
+++ b/test/functional/eval/match_functions_spec.lua
@@ -44,3 +44,18 @@ describe('setmatches()', function()
     eq({}, funcs.getmatches())
   end)
 end)
+
+describe('matchadd()', function()
+  it('correctly works when first two arguments and conceal are numbers at once',
+  function()
+    command('hi def link 1 PreProc')
+    eq(4, funcs.matchadd(1, 2, 3, 4, {conceal=5}))
+    eq({{
+      group='1',
+      pattern='2',
+      priority=3,
+      id=4,
+      conceal='5',
+    }}, funcs.getmatches())
+  end)
+end)
diff --git a/test/functional/ex_cmds/dict_notifications_spec.lua b/test/functional/ex_cmds/dict_notifications_spec.lua
index 057245db1c..8cc717483e 100644
--- a/test/functional/ex_cmds/dict_notifications_spec.lua
+++ b/test/functional/ex_cmds/dict_notifications_spec.lua
@@ -9,7 +9,7 @@ local eval = helpers.eval
 describe('dictionary change notifications', function()
   local channel
 
-  setup(function()
+  before_each(function()
     clear()
     channel = nvim('get_api_info')[1]
     nvim('set_var', 'channel', channel)
@@ -18,19 +18,15 @@ describe('dictionary change notifications', function()
   -- the same set of tests are applied to top-level dictionaries(g:, b:, w: and
   -- t:) and a dictionary variable, so we generate them in the following
   -- function.
-  local function gentests(dict_expr, dict_expr_suffix, dict_init)
-    if not dict_expr_suffix then
-      dict_expr_suffix = ''
-    end
-
+  local function gentests(dict_expr, dict_init)
     local function update(opval, key)
       if not key then
         key = 'watched'
       end
       if opval == '' then
-        nvim('command', "unlet "..dict_expr..dict_expr_suffix..key)
+        command(('unlet %s[\'%s\']'):format(dict_expr, key))
       else
-        nvim('command', "let "..dict_expr..dict_expr_suffix..key.." "..opval)
+        command(('let %s[\'%s\'] %s'):format(dict_expr, key, opval))
       end
     end
 
@@ -50,7 +46,7 @@ describe('dictionary change notifications', function()
 
     describe(dict_expr .. ' watcher', function()
       if dict_init then
-        setup(function()
+        before_each(function()
           source(dict_init)
         end)
       end
@@ -143,6 +139,32 @@ describe('dictionary change notifications', function()
         ]])
       end)
 
+      it('is triggered for empty keys', function()
+        command([[
+        call dictwatcheradd(]]..dict_expr..[[, "", "g:Changed")
+        ]])
+        update('= 1', '')
+        verify_value({new = 1}, '')
+        update('= 2', '')
+        verify_value({old = 1, new = 2}, '')
+        command([[
+        call dictwatcherdel(]]..dict_expr..[[, "", "g:Changed")
+        ]])
+      end)
+
+      it('is triggered for empty keys when using catch-all *', function()
+        command([[
+        call dictwatcheradd(]]..dict_expr..[[, "*", "g:Changed")
+        ]])
+        update('= 1', '')
+        verify_value({new = 1}, '')
+        update('= 2', '')
+        verify_value({old = 1, new = 2}, '')
+        command([[
+        call dictwatcherdel(]]..dict_expr..[[, "*", "g:Changed")
+        ]])
+      end)
+
       -- test a sequence of updates of different types to ensure proper memory
       -- management(with ASAN)
       local function test_updates(tests)
@@ -190,10 +212,10 @@ describe('dictionary change notifications', function()
   gentests('b:')
   gentests('w:')
   gentests('t:')
-  gentests('g:dict_var', '.', 'let g:dict_var = {}')
+  gentests('g:dict_var', 'let g:dict_var = {}')
 
   describe('multiple watchers on the same dict/key', function()
-    setup(function()
+    before_each(function()
       source([[
       function! g:Watcher1(dict, key, value)
         call rpcnotify(g:channel, '1', a:key, a:value)
@@ -213,6 +235,9 @@ describe('dictionary change notifications', function()
     end)
 
     it('only removes watchers that fully match dict, key and callback', function()
+      nvim('command', 'let g:key = "value"')
+      eq({'notification', '1', {'key', {new = 'value'}}}, next_msg())
+      eq({'notification', '2', {'key', {new = 'value'}}}, next_msg())
       nvim('command', 'call dictwatcherdel(g:, "key", "g:Watcher1")')
       nvim('command', 'let g:key = "v2"')
       eq({'notification', '2', {'key', {old = 'value', new = 'v2'}}}, next_msg())
@@ -220,6 +245,17 @@ describe('dictionary change notifications', function()
   end)
 
   describe('errors', function()
+    before_each(function()
+      source([[
+      function! g:Watcher1(dict, key, value)
+        call rpcnotify(g:channel, '1', a:key, a:value)
+      endfunction
+      function! g:Watcher2(dict, key, value)
+        call rpcnotify(g:channel, '2', a:key, a:value)
+      endfunction
+      ]])
+    end)
+
     -- WARNING: This suite depends on the above tests
     it('fails to remove if no watcher with matching callback is found', function()
       eq("Vim(call):Couldn't find a watcher matching key and callback",
@@ -236,15 +272,10 @@ describe('dictionary change notifications', function()
       command('call dictwatcherdel(g:, "key", "g:InvalidCb")')
     end)
 
-    it('fails with empty keys', function()
-      eq("Vim(call):E713: Cannot use empty key for Dictionary",
-        exc_exec('call dictwatcheradd(g:, "", "g:Watcher1")'))
-      eq("Vim(call):E713: Cannot use empty key for Dictionary",
-        exc_exec('call dictwatcherdel(g:, "", "g:Watcher1")'))
-    end)
-
     it('does not fail to replace a watcher function', function()
       source([[
+      let g:key = 'v2'
+      call dictwatcheradd(g:, "key", "g:Watcher2")
       function! g:ReplaceWatcher2()
         function! g:Watcher2(dict, key, value)
           call rpcnotify(g:channel, '2b', a:key, a:value)