refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459

57 files changed, 511 insertions, 508 deletions

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 514be4c56b..8f23102e2e 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -3701,7 +3701,7 @@ static int chk_modeline(linenr_T lnum, int flags)
   int retval = OK;
 
   prev = -1;
-  for (s = (char *)ml_get(lnum); *s != NUL; s++) {
+  for (s = ml_get(lnum); *s != NUL; s++) {
     if (prev == -1 || ascii_isspace(prev)) {
       if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0)
           || STRNCMP(s, "vi:", (size_t)3) == 0) {
diff --git a/src/nvim/change.c b/src/nvim/change.c
index 85ab92e49b..5bea388f28 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -631,7 +631,7 @@ void ins_char_bytes(char *buf, size_t charlen)
 
   size_t col = (size_t)curwin->w_cursor.col;
   linenr_T lnum = curwin->w_cursor.lnum;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   size_t linelen = STRLEN(oldp) + 1;  // length of old line including NUL
 
   // The lengths default to the values for when not replacing.
@@ -739,7 +739,7 @@ void ins_str(char *s)
   }
 
   colnr_T col = curwin->w_cursor.col;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   int oldlen = (int)STRLEN(oldp);
 
   char *newp = xmalloc((size_t)oldlen + (size_t)newlen + 1);
@@ -797,7 +797,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   linenr_T lnum = curwin->w_cursor.lnum;
   colnr_T col = curwin->w_cursor.col;
   bool fixpos = fixpos_arg;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   colnr_T oldlen = (colnr_T)STRLEN(oldp);
 
   // Can't do anything when the cursor is on the NUL after the line.
@@ -843,7 +843,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
         && (get_ve_flags() & VE_ONEMORE) == 0) {
       curwin->w_cursor.col--;
       curwin->w_cursor.coladd = 0;
-      curwin->w_cursor.col -= utf_head_off((char_u *)oldp, (char_u *)oldp + curwin->w_cursor.col);
+      curwin->w_cursor.col -= utf_head_off(oldp, oldp + curwin->w_cursor.col);
     }
     count = oldlen - col;
     movelen = 1;
@@ -854,7 +854,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   bool was_alloced = ml_line_alloced();     // check if oldp was allocated
   char *newp;
   if (was_alloced) {
-    ml_add_deleted_len(curbuf->b_ml.ml_line_ptr, oldlen);
+    ml_add_deleted_len((char *)curbuf->b_ml.ml_line_ptr, oldlen);
     newp = oldp;                            // use same allocated memory
   } else {                                  // need to allocate a new line
     newp = xmalloc((size_t)(oldlen + 1 - count));
@@ -1047,7 +1047,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     // the line, replacing what was there before and pushing the right
     // stuff onto the replace stack.  -- webb.
     if (curwin->w_cursor.lnum < orig_line_count) {
-      next_line = (char *)vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
+      next_line = xstrdup(ml_get(curwin->w_cursor.lnum + 1));
     } else {
       next_line = xstrdup("");
     }
@@ -1119,7 +1119,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
         // Skip preprocessor directives, unless they are recognised as comments.
         if (lead_len == 0 && ptr[0] == '#') {
           while (ptr[0] == '#' && curwin->w_cursor.lnum > 1) {
-            ptr = (char *)ml_get(--curwin->w_cursor.lnum);
+            ptr = ml_get(--curwin->w_cursor.lnum);
           }
           newindent = get_indent();
         }
@@ -1210,7 +1210,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
             } else {
               was_backslashed = false;
             }
-            ptr = (char *)ml_get(++curwin->w_cursor.lnum);
+            ptr = ml_get(++curwin->w_cursor.lnum);
           }
           if (was_backslashed) {
             newindent = 0;  // Got to end of file
@@ -1465,7 +1465,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
 
           // blank-out any other chars from the old leader.
           while (--p >= leader) {
-            int l = utf_head_off((char_u *)leader, (char_u *)p);
+            int l = utf_head_off(leader, p);
 
             if (l > 1) {
               p -= l;
@@ -1872,7 +1872,7 @@ void truncate_line(int fixpos)
   if (col == 0) {
     newp = xstrdup("");
   } else {
-    newp = (char *)vim_strnsave(ml_get(lnum), (size_t)col);
+    newp = xstrnsave(ml_get(lnum), (size_t)col);
   }
   ml_replace(lnum, newp, false);
 
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 4efd8a4ad1..4604bf7716 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -927,11 +927,11 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
       }
     }
     posptr = ptr + pos->col;
-    posptr -= utf_head_off(line, posptr);
+    posptr -= utf_head_off((char *)line, (char *)posptr);
   }
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, pos->lnum, 0, (char *)line, (char *)line);
 
   // This function is used very often, do some speed optimizations.
   // When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 5c54404aab..1c35f28301 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -675,7 +675,7 @@ int showmatches(expand_T *xp, int wildmenu)
           msg_advance(maxlen + 1);
           msg_puts((const char *)p);
           msg_advance(maxlen + 3);
-          msg_outtrans_long_attr(p + 2, HL_ATTR(HLF_D));
+          msg_outtrans_long_attr((char *)p + 2, HL_ATTR(HLF_D));
           break;
         }
         for (j = maxlen - lastlen; --j >= 0;) {
@@ -2720,7 +2720,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int j = cclp->cmdpos;
       int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
+        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])) {
           found = true;
           break;
@@ -2741,7 +2741,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int j = cclp->cmdpos - 1;
       int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
+        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])
 #ifdef BACKSLASH_IN_FILENAME
             && vim_strchr((const char_u *)" *?[{`$%#", cclp->cmdbuff[j + 1])
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index ed0488cf76..54e5ffff37 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -138,7 +138,7 @@ static int coladvance2(pos_T *pos, bool addspaces, bool finetune, colnr_T wcol_a
     }
 
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+    init_chartabsize_arg(&cts, curwin, pos->lnum, 0, (char *)line, (char *)line);
     while (cts.cts_vcol <= wcol && *cts.cts_ptr != NUL) {
       // Count a tab for what it's worth (if list mode not on)
       csize = win_lbr_chartabsize(&cts, &head);
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 1cfb535fe8..a3046bb7d7 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2348,8 +2348,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
 
       // Move back to first byte of character in both lines (may
       // have "nn^" in line_org and "n^ in line_new).
-      si_org -= utf_head_off((char_u *)line_org, (char_u *)line_org + si_org);
-      si_new -= utf_head_off((char_u *)line_new, (char_u *)line_new + si_new);
+      si_org -= utf_head_off(line_org, line_org + si_org);
+      si_new -= utf_head_off(line_new, line_new + si_new);
 
       if (*startp > si_org) {
         *startp = si_org;
@@ -2381,8 +2381,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
             const char_u *p1 = (char_u *)line_org + ei_org;
             const char_u *p2 = (char_u *)line_new + ei_new;
 
-            p1 -= utf_head_off((char_u *)line_org, p1);
-            p2 -= utf_head_off((char_u *)line_new, p2);
+            p1 -= utf_head_off(line_org, (char *)p1);
+            p2 -= utf_head_off(line_new, (char *)p2);
 
             if (!diff_equal_char(p1, p2, &l)) {
               break;
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index b6c4400c60..66d8a1fb32 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -943,7 +943,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
     chartabsize_T cts;
     int charsize;
 
-    init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, ptr);
+    init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, (char *)line, (char *)ptr);
     while (cts.cts_vcol < v && *cts.cts_ptr != NUL) {
       charsize = win_lbr_chartabsize(&cts, NULL);
       cts.cts_vcol += charsize;
@@ -1803,11 +1803,11 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         // Found last space before word: check for line break.
         if (wp->w_p_lbr && c0 == c && vim_isbreak(c)
             && !vim_isbreak((int)(*ptr))) {
-          int mb_off = utf_head_off(line, ptr - 1);
+          int mb_off = utf_head_off((char *)line, (char *)ptr - 1);
           char_u *p = ptr - (mb_off + 1);
           chartabsize_T cts;
 
-          init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, p);
+          init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, (char *)line, (char *)p);
           n_extra = win_lbr_chartabsize(&cts, NULL) - 1;
 
           // We have just drawn the showbreak value, no need to add
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index aee8389900..642162284c 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1545,7 +1545,7 @@ void display_dollar(colnr_T col)
 
   // If on the last byte of a multi-byte move to the first byte.
   char_u *p = get_cursor_line_ptr();
-  curwin->w_cursor.col -= utf_head_off(p, p + col);
+  curwin->w_cursor.col -= utf_head_off((char *)p, (char *)p + col);
   curs_columns(curwin, false);              // Recompute w_wrow and w_wcol
   if (curwin->w_wcol < curwin->w_grid.cols) {
     edit_putchar('$', false);
@@ -1672,7 +1672,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     last_vcol = 0;
     ptr = get_cursor_line_ptr();
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, 0, ptr, ptr);
+    init_chartabsize_arg(&cts, curwin, 0, 0, (char *)ptr, (char *)ptr);
     while (cts.cts_vcol <= (int)curwin->w_virtcol) {
       last_vcol = cts.cts_vcol;
       if (cts.cts_vcol > 0) {
@@ -4642,7 +4642,7 @@ static bool ins_tab(void)
 
     char_u *tab = (char_u *)"\t";
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, vcol, tab, tab);
+    init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)tab, (char *)tab);
 
     // Use as many TABs as possible.  Beware of 'breakindent', 'showbreak'
     // and 'linebreak' adding extra virtual columns.
@@ -4671,7 +4671,7 @@ static bool ins_tab(void)
     if (change_col >= 0) {
       int repl_off = 0;
       // Skip over the spaces we need.
-      init_chartabsize_arg(&cts, curwin, 0, vcol, ptr, ptr);
+      init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)ptr, (char *)ptr);
       while (cts.cts_vcol < want_vcol && *cts.cts_ptr == ' ') {
         cts.cts_vcol += lbr_chartabsize(&cts);
         cts.cts_ptr++;
@@ -4869,12 +4869,12 @@ int ins_copychar(linenr_T lnum)
   }
 
   // try to advance to the cursor column
-  line = ml_get(lnum);
+  line = (char_u *)ml_get(lnum);
   prev_ptr = line;
   validate_virtcol();
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, curwin, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, curwin, lnum, 0, (char *)line, (char *)line);
   while (cts.cts_vcol < curwin->w_virtcol && *cts.cts_ptr != NUL) {
     prev_ptr = (char_u *)cts.cts_ptr;
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
@@ -4958,7 +4958,7 @@ static void ins_try_si(int c)
        * case where an "if (..\n..) {" statement continues over multiple
        * lines -- webb
        */
-      ptr = ml_get(pos->lnum);
+      ptr = (char_u *)ml_get(pos->lnum);
       i = pos->col;
       if (i > 0) {              // skip blanks before '{'
         while (--i > 0 && ascii_iswhite(ptr[i])) {}
@@ -4983,7 +4983,7 @@ static void ins_try_si(int c)
         old_pos = curwin->w_cursor;
         i = get_indent();
         while (curwin->w_cursor.lnum > 1) {
-          ptr = (char_u *)skipwhite((char *)ml_get(--(curwin->w_cursor.lnum)));
+          ptr = (char_u *)skipwhite(ml_get(--(curwin->w_cursor.lnum)));
 
           // ignore empty lines and lines starting with '#'.
           if (*ptr != '#' && *ptr != NUL) {
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 2dbaa2f8ac..2ade64df3f 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -6369,7 +6369,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
     }
     int len;
     if (charcol) {
-      len = mb_charlen(ml_get(pos.lnum));
+      len = mb_charlen((char_u *)ml_get(pos.lnum));
     } else {
       len = (int)STRLEN(ml_get(pos.lnum));
     }
@@ -8630,7 +8630,7 @@ void invoke_prompt_callback(void)
   if (curbuf->b_prompt_callback.type == kCallbackNone) {
     return;
   }
-  char *text = (char *)ml_get(lnum);
+  char *text = ml_get(lnum);
   char *prompt = (char *)prompt_text();
   if (STRLEN(text) >= STRLEN(prompt)) {
     text += STRLEN(prompt);
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index aa328d50ef..6593a34f4a 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1034,7 +1034,7 @@ static void f_confirm(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   if (!error) {
-    rettv->vval.v_number = do_dialog(type, NULL, (char_u *)message, (char_u *)buttons, def, NULL,
+    rettv->vval.v_number = do_dialog(type, NULL, (char *)message, (char *)buttons, def, NULL,
                                      false);
   }
 }
@@ -3849,7 +3849,7 @@ static void f_hostname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   os_get_hostname(hostname, 256);
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)vim_strsave((char_u *)hostname);
+  rettv->vval.v_string = xstrdup(hostname);
 }
 
 /// iconv() function
@@ -5385,7 +5385,7 @@ static void f_nextnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
       lnum = 0;
       break;
     }
-    if (*skipwhite((char *)ml_get(lnum)) != NUL) {
+    if (*skipwhite(ml_get(lnum)) != NUL) {
       break;
     }
   }
@@ -5473,7 +5473,7 @@ static void f_prevnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
   if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) {
     lnum = 0;
   } else {
-    while (lnum >= 1 && *skipwhite((char *)ml_get(lnum)) == NUL) {
+    while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL) {
       lnum--;
     }
   }
@@ -7810,7 +7810,7 @@ free_lstval:
     if (strval == NULL) {
       return;
     }
-    write_reg_contents_ex(regname, (const char_u *)strval, (ssize_t)STRLEN(strval),
+    write_reg_contents_ex(regname, strval, (ssize_t)STRLEN(strval),
                           append, yank_type, (colnr_T)block_len);
   }
   if (pointreg != 0) {
@@ -9639,7 +9639,7 @@ static void f_win_gettype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   if (argvars[0].v_type != VAR_UNKNOWN) {
     wp = find_win_by_nr_or_id(&argvars[0]);
     if (wp == NULL) {
-      rettv->vval.v_string = (char *)vim_strsave((char_u *)"unknown");
+      rettv->vval.v_string = xstrdup("unknown");
       return;
     }
   }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 4be922a055..21bd662db5 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -378,7 +378,7 @@ char_u *deref_func_name(const char *name, int *lenp, partial_T **const partialp,
       *lenp = 0;
       return (char_u *)"";
     }
-    *lenp = (int)STRLEN(v->di_tv.vval.v_string);
+    *lenp = (int)strlen(v->di_tv.vval.v_string);
     return (char_u *)v->di_tv.vval.v_string;
   }
 
@@ -970,11 +970,11 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
       snprintf((char *)numbuf, sizeof(numbuf), "%d", ai + 1);
       name = (char *)numbuf;
     }
-    if (fixvar_idx < FIXVAR_CNT && STRLEN(name) <= VAR_SHORT_LEN) {
+    if (fixvar_idx < FIXVAR_CNT && strlen(name) <= VAR_SHORT_LEN) {
       v = (dictitem_T *)&fc->fixvar[fixvar_idx++];
       v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
     } else {
-      v = xmalloc(sizeof(dictitem_T) + STRLEN(name));
+      v = xmalloc(sizeof(dictitem_T) + strlen(name));
       v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX | DI_FLAGS_ALLOC;
     }
     STRCPY(v->di_key, name);
@@ -1455,7 +1455,7 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
   rettv->v_type = VAR_UNKNOWN;
 
   if (len <= 0) {
-    len = (int)STRLEN(funcname);
+    len = (int)strlen(funcname);
   }
   if (partial != NULL) {
     fp = partial->pt_func;
@@ -2054,7 +2054,7 @@ void ex_function(exarg_T *eap)
               msg_putchar(' ');
             }
           }
-          msg_prt_line((char_u *)FUNCLINE(fp, j), false);
+          msg_prt_line(FUNCLINE(fp, j), false);
           ui_flush();                  // show a line at a time
           os_breakcheck();
         }
@@ -2270,8 +2270,8 @@ void ex_function(exarg_T *eap)
         } else if (line_arg != NULL && *skipwhite((char *)line_arg) != NUL) {
           nextcmd = line_arg;
         } else if (*p != NUL && *p != '"' && p_verbose > 0) {
-          give_warning2((char_u *)_("W22: Text found after :endfunction: %s"),
-                        p, true);
+          give_warning2(_("W22: Text found after :endfunction: %s"),
+                        (char *)p, true);
         }
         if (nextcmd != NULL) {
           // Another command follows. If the line came from "eap" we
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 75410d40d8..dbbb03b1b8 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -710,8 +710,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg,
-                           (const char_u *)p, (ssize_t)STRLEN(p), false);
+        write_reg_contents(*arg == '@' ? '"' : *arg, p, (ssize_t)STRLEN(p), false);
         arg_end = arg + 1;
       }
       xfree(ptofree);
diff --git a/src/nvim/event/socket.c b/src/nvim/event/socket.c
index 9496a568b9..9ca3dcc276 100644
--- a/src/nvim/event/socket.c
+++ b/src/nvim/event/socket.c
@@ -125,7 +125,7 @@ int socket_watcher_start(SocketWatcher *watcher, int backlog, socket_cb cb)
       // Libuv converts ENOENT to EACCES for Windows compatibility, but if
       // the parent directory does not exist, ENOENT would be more accurate.
       *path_tail(watcher->addr) = NUL;
-      if (!os_path_exists((char_u *)watcher->addr)) {
+      if (!os_path_exists(watcher->addr)) {
         result = UV_ENOENT;
       }
     }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e672b80d69..17d45f207e 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -557,7 +557,7 @@ void ex_sort(exarg_T *eap)
   // matching and number conversion only has to be done once per line.
   // Also get the longest line length for allocating "sortbuf".
   for (lnum = eap->line1; lnum <= eap->line2; lnum++) {
-    s = (char *)ml_get(lnum);
+    s = ml_get(lnum);
     len = (int)STRLEN(s);
     if (maxlen < len) {
       maxlen = len;
@@ -658,7 +658,7 @@ void ex_sort(exarg_T *eap)
       change_occurred = true;
     }
 
-    s = (char *)ml_get(get_lnum);
+    s = ml_get(get_lnum);
     size_t bytelen = STRLEN(s) + 1;  // include EOL in bytelen
     old_count += (bcount_t)bytelen;
     if (!unique || i == 0 || string_compare(s, sortbuf1) != 0) {
@@ -760,7 +760,7 @@ void ex_retab(exarg_T *eap)
     new_ts_str = xstrnsave(new_ts_str, (size_t)(eap->arg - new_ts_str));
   }
   for (lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) {
-    ptr = (char *)ml_get(lnum);
+    ptr = ml_get(lnum);
     col = 0;
     vcol = 0;
     did_undo = false;
@@ -941,7 +941,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     return FAIL;
   }
   for (extra = 0, l = line1; l <= line2; l++) {
-    str = (char *)vim_strsave(ml_get(l + extra));
+    str = xstrdup(ml_get(l + extra));
     ml_append(dest + l - line1, str, (colnr_T)0, false);
     xfree(str);
     if (dest < line1) {
@@ -1088,7 +1088,7 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
   while (line1 <= line2) {
     // need to use vim_strsave() because the line will be unlocked within
     // ml_append()
-    p = (char *)vim_strsave(ml_get(line1));
+    p = xstrdup(ml_get(line1));
     ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, false);
     xfree(p);
 
@@ -1710,7 +1710,7 @@ void print_line(linenr_T lnum, int use_number, int list)
   int save_silent = silent_mode;
 
   // apply :filter /pat/
-  if (message_filtered((char *)ml_get(lnum))) {
+  if (message_filtered(ml_get(lnum))) {
     return;
   }
 
@@ -1897,7 +1897,7 @@ int do_write(exarg_T *eap)
         && !p_wa) {
       if (p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) {
         if (vim_dialog_yesno(VIM_QUESTION, NULL,
-                             (char_u *)_("Write partial file?"), 2) != VIM_YES) {
+                             _("Write partial file?"), 2) != VIM_YES) {
           goto theend;
         }
         eap->forceit = true;
@@ -2007,7 +2007,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
                    && vim_strchr(p_cpo, CPO_OVERNEW) == NULL)
                || (buf->b_flags & BF_READERR))))
       && !p_wa
-      && os_path_exists((char_u *)ffname)) {
+      && os_path_exists(ffname)) {
     if (!eap->forceit && !eap->append) {
 #ifdef UNIX
       // It is possible to open a directory on Unix.
@@ -2020,7 +2020,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
         char buff[DIALOG_MSG_SIZE];
 
         dialog_msg((char *)buff, _("Overwrite existing file \"%s\"?"), fname);
-        if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) != VIM_YES) {
+        if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) != VIM_YES) {
           return FAIL;
         }
         eap->forceit = true;
@@ -2051,14 +2051,14 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
       }
       swapname = (char *)makeswapname((char_u *)fname, (char_u *)ffname, curbuf, (char_u *)dir);
       xfree(dir);
-      if (os_path_exists((char_u *)swapname)) {
+      if (os_path_exists(swapname)) {
         if (p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) {
           char buff[DIALOG_MSG_SIZE];
 
           dialog_msg((char *)buff,
                      _("Swap file \"%s\" exists, overwrite anyway?"),
                      swapname);
-          if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2)
+          if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2)
               != VIM_YES) {
             xfree(swapname);
             return FAIL;
@@ -2171,7 +2171,7 @@ static int check_readonly(int *forceit, buf_T *buf)
   // Handle a file being readonly when the 'readonly' option is set or when
   // the file exists and permissions are read-only.
   if (!*forceit && (buf->b_p_ro
-                    || (os_path_exists((char_u *)buf->b_ffname)
+                    || (os_path_exists(buf->b_ffname)
                         && !os_file_is_writable(buf->b_ffname)))) {
     if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && buf->b_fname != NULL) {
       char buff[DIALOG_MSG_SIZE];
@@ -2187,7 +2187,7 @@ static int check_readonly(int *forceit, buf_T *buf)
                    buf->b_fname);
       }
 
-      if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) == VIM_YES) {
+      if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES) {
         // Set forceit, to force the writing of a readonly file
         *forceit = true;
         return false;
@@ -2678,7 +2678,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     }
     buf = curbuf;
     if (buf->b_fname != NULL) {
-      new_name = (char *)vim_strsave((char_u *)buf->b_fname);
+      new_name = xstrdup(buf->b_fname);
     } else {
       new_name = NULL;
     }
@@ -3803,7 +3803,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           break;
         }
         if (sub_firstline == NULL) {
-          sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum));
+          sub_firstline = xstrdup(ml_get(sub_firstlnum));
         }
 
         // Save the line number of the last change for the final
@@ -3944,7 +3944,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
                 // really update the line, it would change
                 // what matches.  Temporarily replace the line
                 // and change it back afterwards.
-                orig_line = (char *)vim_strsave(ml_get(lnum));
+                orig_line = xstrdup(ml_get(lnum));
                 char *new_line = concat_str(new_start, sub_firstline + copycol);
 
                 // Position the cursor relative to the end of the line, the
@@ -4072,7 +4072,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
     if (nmatch > 1) { \
       sub_firstlnum += (linenr_T)nmatch - 1; \
       xfree(sub_firstline); \
-      sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum)); \
+      sub_firstline = xstrdup(ml_get(sub_firstlnum)); \
       /* When going beyond the last line, stop substituting. */ \
       if (sub_firstlnum <= line2) { \
         do_again = true; \
@@ -4148,7 +4148,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           if (nmatch == 1) {
             p1 = sub_firstline;
           } else {
-            p1 = (char *)ml_get(sub_firstlnum + (linenr_T)nmatch - 1);
+            p1 = ml_get(sub_firstlnum + (linenr_T)nmatch - 1);
             nmatch_tl += nmatch - 1;
           }
           size_t copy_len = (size_t)(regmatch.startpos[0].col - copycol);
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 11280eecbb..e551cbee0b 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -200,9 +200,9 @@ void dialog_changed(buf_T *buf, bool checkall)
 
   dialog_msg((char *)buff, _("Save changes to \"%s\"?"), buf->b_fname);
   if (checkall) {
-    ret = vim_dialog_yesnoallcancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+    ret = vim_dialog_yesnoallcancel(VIM_QUESTION, NULL, buff, 1);
   } else {
-    ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+    ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, buff, 1);
   }
 
   if (ret == VIM_YES) {
@@ -252,7 +252,7 @@ bool dialog_close_terminal(buf_T *buf)
   dialog_msg(buff, _("Close \"%s\"?"),
              (buf->b_fname != NULL) ? buf->b_fname : "?");
 
-  int ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+  int ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, buff, 1);
 
   return ret == VIM_YES;
 }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index bf518f3849..8f72ba0e23 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -535,7 +535,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       if (flags & DOCMD_KEEPLINE) {
         xfree(repeat_cmdline);
         if (count == 0) {
-          repeat_cmdline = (char *)vim_strsave((char_u *)next_cmdline);
+          repeat_cmdline = xstrdup(next_cmdline);
         } else {
           repeat_cmdline = NULL;
         }
@@ -2826,7 +2826,7 @@ static void append_command(char *cmd)
   if (len > IOSIZE - 100) {
     // Not enough space, truncate and put in "...".
     d = (char *)IObuff + IOSIZE - 100;
-    d -= utf_head_off(IObuff, (const char_u *)d);
+    d -= utf_head_off((char *)IObuff, d);
     STRCPY(d, "...");
   }
   STRCAT(IObuff, ": ");
@@ -3081,10 +3081,9 @@ void f_fullcommand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
 
-  rettv->vval.v_string = (char *)vim_strsave(IS_USER_CMDIDX(ea.cmdidx)
-                                             ? (char_u *)get_user_command_name(ea.useridx,
-                                                                               ea.cmdidx)
-                                             : (char_u *)cmdnames[ea.cmdidx].cmd_name);
+  rettv->vval.v_string = xstrdup(IS_USER_CMDIDX(ea.cmdidx)
+                                 ? get_user_command_name(ea.useridx, ea.cmdidx)
+                                 : cmdnames[ea.cmdidx].cmd_name);
 }
 
 cmdidx_T excmd_get_cmdidx(const char *cmd, size_t len)
@@ -4344,7 +4343,7 @@ static int check_more(int message, bool forceit)
         vim_snprintf((char *)buff, DIALOG_MSG_SIZE,
                      NGETTEXT("%d more file to edit.  Quit anyway?",
                               "%d more files to edit.  Quit anyway?", (unsigned long)n), n);
-        if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 1) == VIM_YES) {
+        if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES) {
           return OK;
         }
         return FAIL;
@@ -6007,7 +6006,7 @@ static void ex_redir(exarg_T *eap)
           // Make register empty when not using @A-@Z and the
           // command is valid.
           if (*arg == NUL && !isupper(redir_reg)) {
-            write_reg_contents(redir_reg, (char_u *)"", 0, false);
+            write_reg_contents(redir_reg, "", 0, false);
           }
         }
       }
@@ -6162,7 +6161,7 @@ FILE *open_exfile(char_u *fname, int forceit, char *mode)
     return NULL;
   }
 #endif
-  if (!forceit && *mode != 'a' && os_path_exists(fname)) {
+  if (!forceit && *mode != 'a' && os_path_exists((char *)fname)) {
     semsg(_("E189: \"%s\" exists (add ! to override)"), fname);
     return NULL;
   }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 0998bdd867..e8af99805d 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1704,8 +1704,8 @@ static int command_line_handle_key(CommandLineState *s)
     do {
       ccline.cmdpos--;
       // Move to first byte of possibly multibyte char.
-      ccline.cmdpos -= utf_head_off(ccline.cmdbuff,
-                                    ccline.cmdbuff + ccline.cmdpos);
+      ccline.cmdpos -= utf_head_off((char *)ccline.cmdbuff,
+                                    (char *)ccline.cmdbuff + ccline.cmdpos);
       ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
     } while (ccline.cmdpos > 0
              && (s->c == K_S_LEFT || s->c == K_C_LEFT
@@ -3208,7 +3208,7 @@ draw_cmdline_no_arabicshape:
           continue;
         }
         const int chunk_start = MAX(chunk.start, start);
-        msg_outtrans_len_attr(ccline.cmdbuff + chunk_start,
+        msg_outtrans_len_attr((char *)ccline.cmdbuff + chunk_start,
                               chunk.end - chunk_start,
                               chunk.attr);
       }
@@ -3442,14 +3442,14 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     i = 0;
     c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
     while (ccline.cmdpos > 0 && utf_iscomposing(c)) {
-      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
       ccline.cmdpos -= i;
       len += i;
       c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
     }
     if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c)) {
       // Check the previous character for Arabic combining pair.
-      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
       if (arabic_combine(utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos - i), c)) {
         ccline.cmdpos -= i;
         len += i;
@@ -3581,7 +3581,7 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
 
       // Locate start of last word in the cmd buffer.
       for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff;) {
-        len = utf_head_off(ccline.cmdbuff, w - 1) + 1;
+        len = utf_head_off((char *)ccline.cmdbuff, (char *)w - 1) + 1;
         if (!vim_iswordc(utf_ptr2char((char *)w - len))) {
           break;
         }
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index bbc6e53aa8..e87e0853f3 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -825,7 +825,7 @@ char_u *vim_findfile(void *search_ctx_arg)
             for (;;) {
               // if file exists and we didn't already find it
               if ((path_with_url((char *)file_path)
-                   || (os_path_exists(file_path)
+                   || (os_path_exists((char *)file_path)
                        && (search_ctx->ffsc_find_what == FINDFILE_BOTH
                            || ((search_ctx->ffsc_find_what == FINDFILE_DIR)
                                == os_isdir((char *)file_path)))))
@@ -1473,7 +1473,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
         buf = (char *)suffixes;
         for (;;) {
           if (
-              (os_path_exists((char_u *)NameBuff)
+              (os_path_exists(NameBuff)
                && (find_what == FINDFILE_BOTH
                    || ((find_what == FINDFILE_DIR)
                        == os_isdir(NameBuff))))) {
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index d67cd36a85..517424f4c1 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -143,7 +143,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   msg_scroll = msg_scroll_save;
   msg_scrolled_ign = true;
   // may truncate the message to avoid a hit-return prompt
-  msg_outtrans_attr((char *)msg_may_trunc(false, IObuff), attr);
+  msg_outtrans_attr(msg_may_trunc(false, (char *)IObuff), attr);
   msg_clr_eos();
   ui_flush();
   msg_scrolled_ign = false;
@@ -1011,7 +1011,7 @@ retry:
 
             tlen = 0;
             for (;;) {
-              p = ml_get(read_buf_lnum) + read_buf_col;
+              p = (char_u *)ml_get(read_buf_lnum) + read_buf_col;
               n = (int)STRLEN(p);
               if ((int)tlen + n + 1 > size) {
                 // Filled up to "size", append partial line.
@@ -1371,7 +1371,7 @@ retry:
             if (*--p < 0x80) {
               u8c = *p;
             } else {
-              len = utf_head_off((char_u *)ptr, p);
+              len = utf_head_off(ptr, (char *)p);
               p -= len;
               u8c = (unsigned)utf_ptr2char((char *)p);
               if (len == 0) {
@@ -2970,13 +2970,13 @@ nobackup:
            * delete an existing one, try to use another name.
            * Change one character, just before the extension.
            */
-          if (!p_bk && os_path_exists((char_u *)backup)) {
+          if (!p_bk && os_path_exists(backup)) {
             p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
             if (p < backup) {           // empty file name ???
               p = backup;
             }
             *p = 'z';
-            while (*p > 'a' && os_path_exists((char_u *)backup)) {
+            while (*p > 'a' && os_path_exists(backup)) {
               (*p)--;
             }
             // They all exist??? Must be something wrong!
@@ -3211,11 +3211,11 @@ restore_backup:
               // This may not work if the vim_rename() fails.
               // In that case we leave the copy around.
               // If file does not exist, put the copy in its place
-              if (!os_path_exists((char_u *)fname)) {
+              if (!os_path_exists(fname)) {
                 vim_rename((char_u *)backup, (char_u *)fname);
               }
               // if original file does exist throw away the copy
-              if (os_path_exists((char_u *)fname)) {
+              if (os_path_exists(fname)) {
                 os_remove(backup);
               }
             } else {
@@ -3225,7 +3225,7 @@ restore_backup:
           }
 
           // if original file no longer exists give an extra warning
-          if (!newfile && !os_path_exists((char_u *)fname)) {
+          if (!newfile && !os_path_exists(fname)) {
             end = 0;
           }
         }
@@ -3588,7 +3588,7 @@ restore_backup:
        */
       if (org == NULL) {
         emsg(_("E205: Patchmode: can't save original file"));
-      } else if (!os_path_exists((char_u *)org)) {
+      } else if (!os_path_exists(org)) {
         vim_rename((char_u *)backup, (char_u *)org);
         XFREE_CLEAR(backup);                   // don't delete the file
 #ifdef UNIX
@@ -4677,7 +4677,7 @@ int vim_rename(const char_u *from, const char_u *to)
       char *tail = path_tail((char *)tempname);
       snprintf(tail, (size_t)((MAXPATHL + 1) - (tail - (char *)tempname - 1)), "%d", n);
 
-      if (!os_path_exists(tempname)) {
+      if (!os_path_exists((char *)tempname)) {
         if (os_rename(from, tempname) == OK) {
           if (os_rename(tempname, to) == OK) {
             return 0;
@@ -5028,7 +5028,7 @@ int buf_check_timestamp(buf_T *buf)
       }
     }
   } else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
-             && os_path_exists((char_u *)buf->b_ffname)) {
+             && os_path_exists(buf->b_ffname)) {
     retval = 1;
     mesg = _("W13: Warning: File \"%s\" has been created after editing started");
     buf->b_flags |= BF_NEW_W;
@@ -5051,8 +5051,8 @@ int buf_check_timestamp(buf_T *buf)
         xstrlcat(tbuf, "\n", tbuf_len - 1);
         xstrlcat(tbuf, mesg2, tbuf_len - 1);
       }
-      switch (do_dialog(VIM_WARNING, (char_u *)_("Warning"), (char_u *)tbuf,
-                        (char_u *)_("&OK\n&Load File\nLoad File &and Options"),
+      switch (do_dialog(VIM_WARNING, _("Warning"), tbuf,
+                        _("&OK\n&Load File\nLoad File &and Options"),
                         1, NULL, true)) {
       case 2:
         reload = RELOAD_NORMAL;
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index b4ddb3ec08..d8c864df5b 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -995,7 +995,7 @@ void foldAdjustVisual(void)
     start->col = 0;
   }
   if (hasFolding(end->lnum, NULL, &end->lnum)) {
-    ptr = ml_get(end->lnum);
+    ptr = (char_u *)ml_get(end->lnum);
     end->col = (colnr_T)STRLEN(ptr);
     if (end->col > 0 && *p_sel == 'o') {
       end->col--;
@@ -1588,7 +1588,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t ma
 
   if (u_save(lnum - 1, lnum + 1) == OK) {
     // Check if the line ends with an unclosed comment
-    skip_comment(line, false, false, &line_is_comment);
+    skip_comment((char *)line, false, false, &line_is_comment);
     newline = xmalloc(line_len + markerlen + STRLEN(cms) + 1);
     STRCPY(newline, line);
     // Append the marker to the end of the line
@@ -1601,7 +1601,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t ma
       STRCPY(newline + line_len + (p - cms) + markerlen, p + 2);
       added = markerlen + STRLEN(cms) - 2;
     }
-    ml_replace_buf(buf, lnum, newline, false);
+    ml_replace_buf(buf, lnum, (char *)newline, false);
     if (added) {
       extmark_splice_cols(buf, (int)lnum - 1, (int)line_len,
                           0, (int)added, kExtmarkUndo);
@@ -1666,7 +1666,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
       assert(p >= line);
       memcpy(newline, line, (size_t)(p - line));
       STRCPY(newline + (p - line), p + len);
-      ml_replace_buf(buf, lnum, newline, false);
+      ml_replace_buf(buf, lnum, (char *)newline, false);
       extmark_splice_cols(buf, (int)lnum - 1, (int)(p - line),
                           (int)len, 0, kExtmarkUndo);
     }
@@ -3251,12 +3251,12 @@ void f_foldtext(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
 
     // Find interesting text in this line.
-    char_u *s = (char_u *)skipwhite((char *)ml_get(lnum));
+    char_u *s = (char_u *)skipwhite(ml_get(lnum));
     // skip C comment-start
     if (s[0] == '/' && (s[1] == '*' || s[1] == '/')) {
       s = (char_u *)skipwhite((char *)s + 2);
       if (*skipwhite((char *)s) == NUL && lnum + 1 < foldend) {
-        s = (char_u *)skipwhite((char *)ml_get(lnum + 1));
+        s = (char_u *)skipwhite(ml_get(lnum + 1));
         if (*s == '*') {
           s = (char_u *)skipwhite((char *)s + 1);
         }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 0a9457ef35..4d7339f3b5 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -2569,7 +2569,7 @@ static int vgetorpeek(bool advance)
                 ptr = get_cursor_line_ptr();
                 chartabsize_T cts;
                 init_chartabsize_arg(&cts, curwin,
-                                     curwin->w_cursor.lnum, 0, ptr, ptr);
+                                     curwin->w_cursor.lnum, 0, (char *)ptr, (char *)ptr);
                 while ((char_u *)cts.cts_ptr < ptr + curwin->w_cursor.col) {
                   if (!ascii_iswhite(*cts.cts_ptr)) {
                     curwin->w_wcol = cts.cts_vcol;
@@ -2597,7 +2597,7 @@ static int vgetorpeek(bool advance)
               // Correct when the cursor is on the right halve
               // of a double-wide character.
               ptr = get_cursor_line_ptr();
-              col -= utf_head_off(ptr, ptr + col);
+              col -= utf_head_off((char *)ptr, (char *)ptr + col);
               if (utf_ptr2cells((char *)ptr + col) > 1) {
                 curwin->w_wcol--;
               }
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 602fa8b71d..d7f5730943 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -879,7 +879,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
   }
 
   mch_print_start_line(false, page_line);
-  line = ml_get(ppos->file_line);
+  line = (char_u *)ml_get(ppos->file_line);
 
   /*
    * Loop over the columns until the end of the file line or right margin.
@@ -897,7 +897,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
         id = 0;
       }
       // Get the line again, a multi-line regexp may invalidate it.
-      line = ml_get(ppos->file_line);
+      line = (char_u *)ml_get(ppos->file_line);
 
       if (id != current_syn_id) {
         current_syn_id = id;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 9413abb2e1..e54bffb587 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -446,7 +446,7 @@ staterr:
   if (arg2 != NULL) {
     ppath = xmalloc(MAXPATHL + 1);
     expand_env(arg2, ppath, MAXPATHL);
-    if (!os_path_exists((char_u *)ppath)) {
+    if (!os_path_exists(ppath)) {
       goto staterr;
     }
   }
@@ -1651,7 +1651,7 @@ static void cs_print_tags_priv(char **matches, char **cntxts,
     }
     (void)snprintf(buf, bufsize, csfmt_str, i + 1, lno);
     msg_puts_attr(buf, HL_ATTR(HLF_CM));
-    msg_outtrans_long_attr((char_u *)cs_pathcomponents(fname), HL_ATTR(HLF_CM));
+    msg_outtrans_long_attr(cs_pathcomponents(fname), HL_ATTR(HLF_CM));
 
     // compute the required space for the context
     char *context = cntxts[i] ? cntxts[i] : globalcntx;
@@ -1673,11 +1673,11 @@ static void cs_print_tags_priv(char **matches, char **cntxts,
       msg_putchar('\n');
     }
     msg_advance(12);
-    msg_outtrans_long_attr((char_u *)buf, 0);
+    msg_outtrans_long_attr(buf, 0);
     msg_putchar('\n');
     if (extra != NULL) {
       msg_advance(13);
-      msg_outtrans_long_attr((char_u *)extra, 0);
+      msg_outtrans_long_attr(extra, 0);
     }
 
     // restore matches[i]
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index 792f4d93c4..da4bcf6934 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -352,7 +352,7 @@ int get_indent(void)
 // Count the size (in window cells) of the indent in line "lnum".
 int get_indent_lnum(linenr_T lnum)
 {
-  return get_indent_str_vtab((char *)ml_get(lnum),
+  return get_indent_str_vtab(ml_get(lnum),
                              curbuf->b_p_ts,
                              curbuf->b_p_vts_array,
                              false);
@@ -710,7 +710,7 @@ int get_number_indent(linenr_T lnum)
 
   // In format_lines() (i.e. not insert mode), fo+=q is needed too...
   if ((State & MODE_INSERT) || has_format_option(FO_Q_COMS)) {
-    lead_len = get_leader_len((char *)ml_get(lnum), NULL, false, true);
+    lead_len = get_leader_len(ml_get(lnum), NULL, false, true);
   }
   regmatch.regprog = vim_regcomp(curbuf->b_p_flp, RE_MAGIC);
 
@@ -719,9 +719,9 @@ int get_number_indent(linenr_T lnum)
 
     // vim_regexec() expects a pointer to a line.  This lets us
     // start matching for the flp beyond any comment leader...
-    if (vim_regexec(&regmatch, (char *)ml_get(lnum) + lead_len, (colnr_T)0)) {
+    if (vim_regexec(&regmatch, ml_get(lnum) + lead_len, (colnr_T)0)) {
       pos.lnum = lnum;
-      pos.col = (colnr_T)(*regmatch.endp - ml_get(lnum));
+      pos.col = (colnr_T)(*regmatch.endp - (char_u *)ml_get(lnum));
       pos.coladd = 0;
     }
     vim_regfree(regmatch.regprog);
@@ -1036,7 +1036,7 @@ int get_lisp_indent(void)
       } else {
         char_u *line = that;
         chartabsize_T cts;
-        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, (char *)line, (char *)line);
         while (*cts.cts_ptr != NUL && col > 0) {
           cts.cts_vcol += lbr_chartabsize_adv(&cts);
           col--;
@@ -1060,7 +1060,7 @@ int get_lisp_indent(void)
           firsttry = amount;
 
           init_chartabsize_arg(&cts, curwin, (colnr_T)(that - line),
-                               amount, line, that);
+                               amount, (char *)line, (char *)that);
           while (ascii_iswhite(*cts.cts_ptr)) {
             cts.cts_vcol += lbr_chartabsize(&cts);
             cts.cts_ptr++;
@@ -1081,7 +1081,7 @@ int get_lisp_indent(void)
             quotecount = 0;
 
             init_chartabsize_arg(&cts, curwin,
-                                 (colnr_T)(that - line), amount, line, that);
+                                 (colnr_T)(that - line), amount, (char *)line, (char *)that);
             if (vi_lisp || ((*that != '"') && (*that != '\'')
                             && (*that != '#') && ((*that < '0') || (*that > '9')))) {
               while (*cts.cts_ptr
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 166695ef5b..ccee4dd48a 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -52,7 +52,7 @@ pos_T *find_start_comment(int ind_maxcomment)  // XXX
      * Check if the comment start we found is inside a string.
      * If it is then restrict the search to below this line and try again.
      */
-    if (!is_pos_in_string(ml_get(pos->lnum), pos->col)) {
+    if (!is_pos_in_string((char_u *)ml_get(pos->lnum), pos->col)) {
       break;
     }
     cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
@@ -115,7 +115,7 @@ static pos_T *find_start_rawstring(int ind_maxcomment)  // XXX
 
     // Check if the raw string start we found is inside a string.
     // If it is then restrict the search to below this line and try again.
-    if (!is_pos_in_string(ml_get(pos->lnum), pos->col)) {
+    if (!is_pos_in_string((char_u *)ml_get(pos->lnum), pos->col)) {
       break;
     }
     cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
@@ -291,7 +291,7 @@ static pos_T *find_line_comment(void)  // XXX
 
   pos = curwin->w_cursor;
   while (--pos.lnum > 0) {
-    line = ml_get(pos.lnum);
+    line = (char_u *)ml_get(pos.lnum);
     p = (char_u *)skipwhite((char *)line);
     if (cin_islinecomment(p)) {
       pos.col = (int)(p - line);
@@ -616,7 +616,7 @@ static int get_indent_nolabel(linenr_T lnum)  // XXX
   colnr_T col;
   const char_u *p;
 
-  l = ml_get(lnum);
+  l = (char_u *)ml_get(lnum);
   p = after_label(l);
   if (p == NULL) {
     return 0;
@@ -724,13 +724,14 @@ static int cin_get_equal_amount(linenr_T lnum)
   pos_T fp;
 
   if (lnum > 1) {
-    line = ml_get(lnum - 1);
+    line = (char_u *)ml_get(lnum - 1);
     if (*line != NUL && line[STRLEN(line) - 1] == '\\') {
       return -1;
     }
   }
 
-  line = s = ml_get(lnum);
+  s = (char_u *)ml_get(lnum);
+  line = s;
   while (*s != NUL && vim_strchr("=;{}\"'", *s) == NULL) {
     if (cin_iscomment(s)) {     // ignore comments
       s = cin_skipcomment(s);
@@ -792,14 +793,14 @@ static int cin_ispreproc_cont(const char_u **pp, linenr_T *lnump, int *amount)
     if (lnum == 1) {
       break;
     }
-    line = ml_get(--lnum);
+    line = (char_u *)ml_get(--lnum);
     if (*line == NUL || line[STRLEN(line) - 1] != '\\') {
       break;
     }
   }
 
   if (lnum != *lnump) {
-    *pp = ml_get(*lnump);
+    *pp = (char_u *)ml_get(*lnump);
   }
   if (retval) {
     *amount = candidate_amount;
@@ -895,7 +896,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
   int just_started = true;
 
   if (sp == NULL) {
-    s = ml_get(lnum);
+    s = (char_u *)ml_get(lnum);
   } else {
     s = *sp;
   }
@@ -908,7 +909,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
       curwin->w_cursor.lnum = save_lnum;
       return false;
     }
-    s = ml_get(lnum);
+    s = (char_u *)ml_get(lnum);
   }
 
   curwin->w_cursor.lnum = save_lnum;
@@ -947,7 +948,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
       //       #if defined(x) && {backslash}
       //           defined(y)
       lnum = first_lnum - 1;
-      s = ml_get(lnum);
+      s = (char_u *)ml_get(lnum);
       if (*s == NUL || s[STRLEN(s) - 1] != '\\') {
         retval = true;
       }
@@ -964,7 +965,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
         if (lnum >= curbuf->b_ml.ml_line_count) {
           break;
         }
-        s = ml_get(++lnum);
+        s = (char_u *)ml_get(++lnum);
         if (!cin_ispreproc(s)) {
           break;
         }
@@ -989,7 +990,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
 
 done:
   if (lnum != first_lnum && sp != NULL) {
-    *sp = ml_get(first_lnum);
+    *sp = (char_u *)ml_get(first_lnum);
   }
 
   return retval;
@@ -1121,7 +1122,7 @@ static int cin_iswhileofdo_end(int terminated)
         curwin->w_cursor.col = i;
         trypos = find_match_paren(curbuf->b_ind_maxparen);
         if (trypos != NULL) {
-          s = cin_skipcomment(ml_get(trypos->lnum));
+          s = cin_skipcomment((char_u *)ml_get(trypos->lnum));
           if (*s == '}') {                      // accept "} while (cond);"
             s = cin_skipcomment(s + 1);
           }
@@ -1200,7 +1201,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
    *    {}
    */
   while (lnum > 1) {
-    line = ml_get(lnum - 1);
+    line = (char_u *)ml_get(lnum - 1);
     s = (char_u *)skipwhite((char *)line);
     if (*s == '#' || *s == NUL) {
       break;
@@ -1222,7 +1223,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
   }
 
   pos->lnum = lnum;
-  line = ml_get(lnum);
+  line = (char_u *)ml_get(lnum);
   s = line;
   for (;;) {
     if (*s == NUL) {
@@ -1230,7 +1231,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
         break;
       }
       // Continue in the cursor line.
-      line = ml_get(++lnum);
+      line = (char_u *)ml_get(++lnum);
       s = line;
     }
     if (s == line) {
@@ -1420,7 +1421,8 @@ static int cin_skip2pos(pos_T *trypos)
   const char_u *p;
   const char_u *new_p;
 
-  p = line = ml_get(trypos->lnum);
+  line = (char_u *)ml_get(trypos->lnum);
+  p = line;
   while (*p && (colnr_T)(p - line) < trypos->col) {
     if (cin_iscomment(p)) {
       p = cin_skipcomment(p);
@@ -1952,7 +1954,7 @@ int get_c_indent(void)
   /* Get a copy of the current contents of the line.
    * This is required, because only the most recent line obtained with
    * ml_get is valid! */
-  linecopy = vim_strsave(ml_get(cur_curpos.lnum));
+  linecopy = vim_strsave((char_u *)ml_get(cur_curpos.lnum));
 
   /*
    * In insert mode and the cursor is on a ')' truncate the line at the
@@ -2019,7 +2021,7 @@ int get_c_indent(void)
     if (trypos == NULL && curwin->w_cursor.lnum > 1) {
       // There may be a statement before the comment, search from the end
       // of the line for a comment start.
-      linecomment_pos.col = check_linecomment((char *)ml_get(curwin->w_cursor.lnum - 1));
+      linecomment_pos.col = check_linecomment(ml_get(curwin->w_cursor.lnum - 1));
       if (linecomment_pos.col != MAXCOL) {
         trypos = &linecomment_pos;
         trypos->lnum = curwin->w_cursor.lnum - 1;
@@ -2094,7 +2096,7 @@ int get_c_indent(void)
              * line, use the indent of that line plus offset.  If
              * the middle comment string matches in the previous
              * line, use the indent of that line.  XXX */
-            look = (char_u *)skipwhite((char *)ml_get(curwin->w_cursor.lnum - 1));
+            look = (char_u *)skipwhite(ml_get(curwin->w_cursor.lnum - 1));
             if (STRNCMP(look, lead_start, lead_start_len) == 0) {
               amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
             } else if (STRNCMP(look, lead_middle, lead_middle_len) == 0) {
@@ -2156,7 +2158,7 @@ int get_c_indent(void)
       }
       if (amount == -1) {                           // use the comment opener
         if (!curbuf->b_ind_in_comment2) {
-          start = ml_get(comment_pos->lnum);
+          start = (char_u *)ml_get(comment_pos->lnum);
           look = start + comment_pos->col + 2;  // skip / and *
           if (*look != NUL) {                   // if something after it
             comment_pos->col = (colnr_T)((char_u *)skipwhite((char *)look) - start);
@@ -2208,7 +2210,7 @@ int get_c_indent(void)
       } else {
         amount = -1;
         for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; lnum--) {
-          l = (char_u *)skipwhite((char *)ml_get(lnum));
+          l = (char_u *)skipwhite(ml_get(lnum));
           if (cin_nocode(l)) {                   // skip comment lines
             continue;
           }
@@ -2269,7 +2271,7 @@ int get_c_indent(void)
 
           curwin->w_cursor = cursor_save;
 
-          line = ml_get(outermost.lnum);
+          line = (char_u *)ml_get(outermost.lnum);
 
           is_if_for_while =
             cin_is_if_for_while_before_offset(line, &outermost.col);
@@ -2297,7 +2299,7 @@ int get_c_indent(void)
           }
 
           curwin->w_cursor.lnum = save_lnum;
-          look = ml_get(our_paren_pos.lnum) + look_col;
+          look = (char_u *)ml_get(our_paren_pos.lnum) + look_col;
         }
         if (theline[0] == ')' || (curbuf->b_ind_unclosed == 0
                                   && is_if_for_while == 0)
@@ -2314,7 +2316,7 @@ int get_c_indent(void)
            */
           if (theline[0] != ')') {
             cur_amount = MAXCOL;
-            l = ml_get(our_paren_pos.lnum);
+            l = (char_u *)ml_get(our_paren_pos.lnum);
             if (curbuf->b_ind_unclosed_wrapped
                 && cin_ends_in(l, (char_u *)"(", NULL)) {
               /* look for opening unmatched paren, indent one level
@@ -2435,7 +2437,7 @@ int get_c_indent(void)
       tryposBrace = &tryposCopy;
       trypos = tryposBrace;
       ourscope = trypos->lnum;
-      start = ml_get(ourscope);
+      start = (char_u *)ml_get(ourscope);
 
       /*
        * Now figure out how indented the line is in general.
@@ -3054,7 +3056,7 @@ int get_c_indent(void)
              */
             if (terminated == ',') {
               while (curwin->w_cursor.lnum > 1) {
-                l = ml_get(curwin->w_cursor.lnum - 1);
+                l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
                 if (*l == NUL || l[STRLEN(l) - 1] != '\\') {
                   break;
                 }
@@ -3607,7 +3609,7 @@ term_again:
        *      here;
        */
       while (n == 0 && curwin->w_cursor.lnum > 1) {
-        l = ml_get(curwin->w_cursor.lnum - 1);
+        l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
         if (*l == NUL || l[STRLEN(l) - 1] != '\\') {
           break;
         }
@@ -3670,7 +3672,7 @@ term_again:
       pos_T curpos_save = curwin->w_cursor;
 
       while (curwin->w_cursor.lnum > 1) {
-        look = ml_get(--curwin->w_cursor.lnum);
+        look = (char_u *)ml_get(--curwin->w_cursor.lnum);
         if (!(cin_nocode(look)
               || cin_ispreproc_cont(&look, &curwin->w_cursor.lnum, &amount))) {
           break;
@@ -3702,7 +3704,7 @@ term_again:
      * indent_to_0 here;
      */
     if (cin_ends_in(l, (char_u *)";", NULL)) {
-      l = ml_get(curwin->w_cursor.lnum - 1);
+      l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
       if (cin_ends_in(l, (char_u *)",", NULL)
           || (*l != NUL && l[STRLEN(l) - 1] == '\\')) {
         break;
@@ -3737,7 +3739,7 @@ term_again:
   //        char *foo = "asdf{backslash}
   //                     here";
   if (cur_curpos.lnum > 1) {
-    l = ml_get(cur_curpos.lnum - 1);
+    l = (char_u *)ml_get(cur_curpos.lnum - 1);
     if (*l != NUL && l[STRLEN(l) - 1] == '\\') {
       cur_amount = cin_get_equal_amount(cur_curpos.lnum - 1);
       if (cur_amount > 0) {
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index ba0a36cafe..a530061280 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2177,7 +2177,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
     p = compl_orig_text;
     for (len = 0; p[len] != NUL && p[len] == ptr[len]; len++) {}
     if (len > 0) {
-      len -= utf_head_off(p, p + len);
+      len -= utf_head_off((char *)p, (char *)p + len);
     }
     for (p += len; *p != NUL; MB_PTR_ADV(p)) {
       AppendCharToRedobuff(K_BS);
@@ -3726,16 +3726,16 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
   } else if (--startcol < 0
              || !vim_iswordp(mb_prevptr(line, line + startcol + 1))) {
     // Match any word of at least two chars
-    compl_pattern = (char *)vim_strsave((char_u *)"\\<\\k\\k");
+    compl_pattern = xstrdup("\\<\\k\\k");
     compl_col += curs_col;
     compl_length = 0;
   } else {
     // Search the point of change class of multibyte character
     // or not a word single byte character backward.
-    startcol -= utf_head_off(line, line + startcol);
+    startcol -= utf_head_off((char *)line, (char *)line + startcol);
     int base_class = mb_get_class(line + startcol);
     while (--startcol >= 0) {
-      int head_off = utf_head_off(line, line + startcol);
+      int head_off = utf_head_off((char *)line, (char *)line + startcol);
       if (base_class != mb_get_class(line + startcol - head_off)) {
         break;
       }
@@ -3893,7 +3893,7 @@ static int get_userdefined_compl_info(colnr_T curs_col)
 
   // Setup variables for completion.  Need to obtain "line" again,
   // it may have become invalid.
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   compl_length = curs_col - compl_col;
   compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
 
@@ -3919,7 +3919,7 @@ static int get_spell_compl_info(int startcol, colnr_T curs_col)
     compl_length = (int)curs_col - compl_col;
   }
   // Need to obtain "line" again, it may have become invalid.
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
 
   return OK;
@@ -4036,7 +4036,7 @@ static int ins_compl_start(void)
     return FAIL;
   }
 
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   colnr_T curs_col = curwin->w_cursor.col;
   compl_pending = 0;
 
@@ -4074,7 +4074,7 @@ static int ins_compl_start(void)
   }
   // If "line" was changed while getting completion info get it again.
   if (line_invalid) {
-    line = ml_get(curwin->w_cursor.lnum);
+    line = (char_u *)ml_get(curwin->w_cursor.lnum);
   }
 
   if (compl_status_adding()) {
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index 5601db274b..b84539852f 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -104,7 +104,7 @@
 // MB_PTR_BACK(): backup a pointer to the previous character, taking care of
 // multi-byte characters if needed. Only use with "p" > "s" !
 #define MB_PTR_BACK(s, p) \
-  (p -= utf_head_off((char_u *)(s), (char_u *)(p) - 1) + 1)
+  (p -= utf_head_off((char *)(s), (char *)(p) - 1) + 1)
 
 // MB_CHAR2BYTES(): convert character to bytes and advance pointer to bytes
 #define MB_CHAR2BYTES(c, b) ((b) += utf_char2bytes((c), ((char *)b)))
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 883f946cad..1c7cfea768 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1914,9 +1914,9 @@ static bool do_user_initialization(void)
   char_u *user_vimrc = (char_u *)stdpaths_user_conf_subpath("init.vim");
 
   // init.lua
-  if (os_path_exists(init_lua_path)
+  if (os_path_exists((char *)init_lua_path)
       && do_source((char *)init_lua_path, true, DOSO_VIMRC)) {
-    if (os_path_exists(user_vimrc)) {
+    if (os_path_exists((char *)user_vimrc)) {
       semsg(_("E5422: Conflicting configs: \"%s\" \"%s\""), init_lua_path,
             user_vimrc);
     }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 333fb847f6..d740a0eb77 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -174,7 +174,7 @@ static void showmap(mapblock_T *mp, bool local)
   }
 
   // Display the LHS.  Get length of what we write.
-  len = (size_t)msg_outtrans_special(mp->m_keys, true, 0);
+  len = (size_t)msg_outtrans_special((char *)mp->m_keys, true, 0);
   do {
     msg_putchar(' ');                   // padd with blanks
     len++;
@@ -203,7 +203,7 @@ static void showmap(mapblock_T *mp, bool local)
   } else if (mp->m_str[0] == NUL) {
     msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
   } else {
-    msg_outtrans_special((char_u *)mp->m_str, false, 0);
+    msg_outtrans_special(mp->m_str, false, 0);
   }
 
   if (mp->m_desc != NULL) {
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 9df4d416ff..816599271d 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -819,7 +819,7 @@ static char_u *mark_line(pos_T *mp, int lead_len)
   }
   assert(Columns >= 0);
   // Allow for up to 5 bytes per character.
-  s = vim_strnsave((char_u *)skipwhite((char *)ml_get(mp->lnum)), (size_t)Columns * 5);
+  s = vim_strnsave((char_u *)skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
 
   // Truncate the line to fit it in the window
   len = 0;
@@ -1758,7 +1758,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
     if (*p == NUL || (int)STRLEN(p) < lp->col) {
       lp->col = 0;
     } else {
-      lp->col -= utf_head_off(p, p + lp->col);
+      lp->col -= utf_head_off((char *)p, (char *)p + lp->col);
     }
     // Reset "coladd" when the cursor would be on the right half of a
     // double-wide character.
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index b874f0dc94..f592b54f67 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1618,21 +1618,24 @@ void show_utf8(void)
 /// "base" must be the start of the string, which must be NUL terminated.
 /// If "p" points to the NUL at the end of the string return 0.
 /// Returns 0 when already at the first byte of a character.
-int utf_head_off(const char_u *base, const char_u *p)
+int utf_head_off(const char *base_in, const char *p_in)
 {
   int c;
   int len;
 
-  if (*p < 0x80) {              // be quick for ASCII
+  if ((uint8_t)(*p_in) < 0x80) {              // be quick for ASCII
     return 0;
   }
 
+  const uint8_t *base = (uint8_t *)base_in;
+  const uint8_t *p = (uint8_t *)p_in;
+
   // Skip backwards over trailing bytes: 10xx.xxxx
   // Skip backwards again if on a composing char.
-  const char_u *q;
+  const uint8_t *q;
   for (q = p;; q--) {
     // Move s to the last byte of this char.
-    const char_u *s;
+    const uint8_t *s;
     for (s = q; (s[1] & 0xc0) == 0x80; s++) {}
 
     // Move q to the first byte of this char.
@@ -1657,7 +1660,7 @@ int utf_head_off(const char_u *base, const char_u *p)
 
     if (arabic_maycombine(c)) {
       // Advance to get a sneak-peak at the next char
-      const char_u *j = q;
+      const uint8_t *j = q;
       j--;
       // Move j to the first byte of this char.
       while (j > base && (*j & 0xc0) == 0x80) {
@@ -2042,7 +2045,7 @@ void mb_check_adjust_col(void *win_)
         win->w_cursor.col = len - 1;
       }
       // Move the cursor to the head byte.
-      win->w_cursor.col -= utf_head_off((char_u *)p, (char_u *)p + win->w_cursor.col);
+      win->w_cursor.col -= utf_head_off(p, p + win->w_cursor.col);
     }
 
     // Reset `coladd` when the cursor would be on the right half of a
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index b0b6b675cb..a30a98d6e9 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1177,7 +1177,7 @@ void ml_recover(bool checkext)
   } else {
     for (idx = 1; idx <= lnum; idx++) {
       // Need to copy one line, fetching the other one may flush it.
-      p = vim_strsave(ml_get(idx));
+      p = vim_strsave((char_u *)ml_get(idx));
       i = STRCMP(p, ml_get(idx + lnum));
       xfree(p);
       if (i != 0) {
@@ -1276,7 +1276,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
 #ifdef HAVE_READLINK
     // Expand symlink in the file name, because the swap file is created
     // with the actual file instead of with the symlink.
-    if (resolve_symlink(fname, fname_buf) == OK) {
+    if (resolve_symlink((char *)fname, (char *)fname_buf) == OK) {
       fname_res = fname_buf;
     } else
 #endif
@@ -1351,7 +1351,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
     if (*dirp == NUL && file_count + num_files == 0 && fname != NULL) {
       char_u *swapname = (char_u *)modname((char *)fname_res, ".swp", true);
       if (swapname != NULL) {
-        if (os_path_exists(swapname)) {
+        if (os_path_exists((char *)swapname)) {
           files = xmalloc(sizeof(char_u *));
           files[0] = (char *)swapname;
           swapname = NULL;
@@ -1399,7 +1399,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
         }
       } else {
         msg_puts(_("   In directory "));
-        msg_home_replace(dir_name);
+        msg_home_replace((char *)dir_name);
         msg_puts(":\n");
       }
 
@@ -1592,7 +1592,7 @@ static bool swapfile_unchanged(char *fname)
   int ret = true;
 
   // Swap file must exist.
-  if (!os_path_exists((char_u *)fname)) {
+  if (!os_path_exists(fname)) {
     return false;
   }
 
@@ -1793,9 +1793,9 @@ theend:
 ///
 /// On failure an error message is given and IObuff is returned (to avoid
 /// having to check for error everywhere).
-char_u *ml_get(linenr_T lnum)
+char *ml_get(linenr_T lnum)
 {
-  return ml_get_buf(curbuf, lnum, false);
+  return (char *)ml_get_buf(curbuf, lnum, false);
 }
 
 /// @return  pointer to position "pos".
@@ -2414,9 +2414,9 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
   return OK;
 }
 
-void ml_add_deleted_len(char_u *ptr, ssize_t len)
+void ml_add_deleted_len(char *ptr, ssize_t len)
 {
-  ml_add_deleted_len_buf(curbuf, ptr, len);
+  ml_add_deleted_len_buf(curbuf, (char_u *)ptr, len);
 }
 
 void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len)
@@ -2439,7 +2439,7 @@ void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len)
 
 int ml_replace(linenr_T lnum, char *line, bool copy)
 {
-  return ml_replace_buf(curbuf, lnum, (char_u *)line, copy);
+  return ml_replace_buf(curbuf, lnum, line, copy);
 }
 
 /// Replace line "lnum", with buffering, in current buffer.
@@ -2454,7 +2454,7 @@ int ml_replace(linenr_T lnum, char *line, bool copy)
 /// changed_lines(), unless update_screen(UPD_NOT_VALID) is used.
 ///
 /// @return  FAIL for failure, OK otherwise
-int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
+int ml_replace_buf(buf_T *buf, linenr_T lnum, char *line, bool copy)
 {
   if (line == NULL) {           // just checking...
     return FAIL;
@@ -2468,7 +2468,7 @@ int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
   bool readlen = true;
 
   if (copy) {
-    line = vim_strsave(line);
+    line = xstrdup(line);
   }
   if (buf->b_ml.ml_line_lnum != lnum) {  // other line buffered
     ml_flush_line(buf);  // flush it
@@ -2483,7 +2483,7 @@ int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
     ml_add_deleted_len_buf(buf, ml_get_buf(buf, lnum, false), -1);
   }
 
-  buf->b_ml.ml_line_ptr = line;
+  buf->b_ml.ml_line_ptr = (char_u *)line;
   buf->b_ml.ml_line_lnum = lnum;
   buf->b_ml.ml_flags = (buf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
 
@@ -3142,9 +3142,9 @@ static void ml_lineadd(buf_T *buf, int count)
 ///
 /// @return  OK if it worked and the resolved link in "buf[MAXPATHL]",
 ///          FAIL otherwise
-int resolve_symlink(const char_u *fname, char_u *buf)
+int resolve_symlink(const char *fname, char *buf)
 {
-  char_u tmp[MAXPATHL];
+  char tmp[MAXPATHL];
   int ret;
   int depth = 0;
 
@@ -3162,7 +3162,7 @@ int resolve_symlink(const char_u *fname, char_u *buf)
       return FAIL;
     }
 
-    ret = (int)readlink((char *)tmp, (char *)buf, MAXPATHL - 1);
+    ret = (int)readlink(tmp, buf, MAXPATHL - 1);
     if (ret <= 0) {
       if (errno == EINVAL || errno == ENOENT) {
         // Found non-symlink or not existing file, stop here.
@@ -3185,10 +3185,10 @@ int resolve_symlink(const char_u *fname, char_u *buf)
     // If it's relative, build a new path based on the directory
     // portion of the filename (if any) and the path the symlink
     // points to.
-    if (path_is_absolute(buf)) {
+    if (path_is_absolute((char_u *)buf)) {
       STRCPY(tmp, buf);
     } else {
-      char_u *tail = (char_u *)path_tail((char *)tmp);
+      char_u *tail = (char_u *)path_tail(tmp);
       if (STRLEN(tail) + STRLEN(buf) >= MAXPATHL) {
         return FAIL;
       }
@@ -3201,7 +3201,7 @@ int resolve_symlink(const char_u *fname, char_u *buf)
    * be consistent even when opening a relative symlink from different
    * working directories.
    */
-  return vim_FullName((char *)tmp, (char *)buf, MAXPATHL, true);
+  return vim_FullName(tmp, buf, MAXPATHL, true);
 }
 #endif
 
@@ -3217,7 +3217,7 @@ char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name
 
   // Expand symlink in the file name, so that we put the swap file with the
   // actual file instead of with the symlink.
-  if (resolve_symlink(fname, fname_buf) == OK) {
+  if (resolve_symlink((char *)fname, (char *)fname_buf) == OK) {
     fname_res = fname_buf;
   }
 #endif
@@ -3300,7 +3300,7 @@ static void attention_message(buf_T *buf, char_u *fname)
   no_wait_return++;
   (void)emsg(_("E325: ATTENTION"));
   msg_puts(_("\nFound a swap file by the name \""));
-  msg_home_replace(fname);
+  msg_home_replace((char *)fname);
   msg_puts("\"\n");
   const time_t swap_mtime = swapfile_info(fname);
   msg_puts(_("While opening file \""));
@@ -3499,7 +3499,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
           // It's safe to delete the swap file if all these are true:
           // - the edited file exists
           // - the swap file has no changes and looks OK
-          if (os_path_exists((char_u *)buf->b_fname) && swapfile_unchanged(fname)) {
+          if (os_path_exists(buf->b_fname) && swapfile_unchanged(fname)) {
             choice = 4;
             if (p_verbose > 0) {
               verb_msg(_("Found a swap file that is not useful, deleting it"));
@@ -3541,13 +3541,13 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             memcpy(name, sw_msg_1, sw_msg_1_len + 1);
             home_replace(NULL, fname, &name[sw_msg_1_len], fname_len, true);
             xstrlcat(name, sw_msg_2, name_len);
-            choice = do_dialog(VIM_WARNING, (char_u *)_("VIM - ATTENTION"),
-                               (char_u *)name,
+            choice = do_dialog(VIM_WARNING, _("VIM - ATTENTION"),
+                               name,
                                process_still_running
-                               ? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover"
-                                             "\n&Quit\n&Abort") :
-                               (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover"
-                                           "\n&Delete it\n&Quit\n&Abort"),
+                               ? _("&Open Read-Only\n&Edit anyway\n&Recover"
+                                   "\n&Quit\n&Abort") :
+                               _("&Open Read-Only\n&Edit anyway\n&Recover"
+                                 "\n&Delete it\n&Quit\n&Abort"),
                                1, NULL, false);
 
             if (process_still_running && choice >= 4) {
@@ -3582,7 +3582,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             }
 
             // If the file was deleted this fname can be used.
-            if (!os_path_exists((char_u *)fname)) {
+            if (!os_path_exists(fname)) {
               break;
             }
           } else {
@@ -4212,8 +4212,8 @@ int dec(pos_T *lp)
   lp->coladd = 0;
   if (lp->col == MAXCOL) {
     // past end of line
-    char_u *p = ml_get(lp->lnum);
-    lp->col = (colnr_T)STRLEN(p);
+    char *p = ml_get(lp->lnum);
+    lp->col = (colnr_T)strlen(p);
     lp->col -= utf_head_off(p, p + lp->col);
     return 0;
   }
@@ -4221,15 +4221,15 @@ int dec(pos_T *lp)
   if (lp->col > 0) {
     // still within line
     lp->col--;
-    char_u *p = ml_get(lp->lnum);
+    char *p = ml_get(lp->lnum);
     lp->col -= utf_head_off(p, p + lp->col);
     return 0;
   }
   if (lp->lnum > 1) {
     // there is a prior line
     lp->lnum--;
-    char_u *p = ml_get(lp->lnum);
-    lp->col = (colnr_T)STRLEN(p);
+    char *p = ml_get(lp->lnum);
+    lp->col = (colnr_T)strlen(p);
     lp->col -= utf_head_off(p, p + lp->col);
     return 1;
   }
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index cb6918cd27..84a1defbe0 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -888,7 +888,7 @@ static void show_menus_recursive(vimmenu_T *menu, int modes, int depth)
         if (*menu->strings[bit] == NUL) {
           msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
         } else {
-          msg_outtrans_special((char_u *)menu->strings[bit], false, 0);
+          msg_outtrans_special(menu->strings[bit], false, 0);
         }
       }
     }
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 80b5f53f4e..e7959c73c6 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -59,7 +59,7 @@ struct msgchunk_S {
   char sb_eol;                  // true when line ends after this text
   int sb_msg_col;               // column in which text starts
   int sb_attr;                  // text attributes
-  char_u sb_text[1];            // text to be displayed, actually longer
+  char sb_text[1];              // text to be displayed, actually longer
 };
 
 // Magic chars used in confirm dialog strings
@@ -70,8 +70,8 @@ static int confirm_msg_used = false;            // displaying confirm_msg
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "message.c.generated.h"
 #endif
-static char_u *confirm_msg = NULL;            // ":confirm" message
-static char_u *confirm_msg_tail;              // tail of confirm_msg
+static char *confirm_msg = NULL;            // ":confirm" message
+static char *confirm_msg_tail;              // tail of confirm_msg
 
 MessageHistoryEntry *first_msg_hist = NULL;
 MessageHistoryEntry *last_msg_hist = NULL;
@@ -251,7 +251,7 @@ void msg_multiline_attr(const char *s, int attr, bool check_int, bool *need_clea
 
     if (next_spec != NULL) {
       // Printing all char that are before the char found by strpbrk
-      msg_outtrans_len_attr((const char_u *)s, (int)(next_spec - s), attr);
+      msg_outtrans_len_attr(s, (int)(next_spec - s), attr);
 
       if (*next_spec != TAB && *need_clear) {
         msg_clr_eos();
@@ -294,7 +294,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 {
   static int entered = 0;
   int retval;
-  char_u *buf = NULL;
+  char *buf = NULL;
 
   if (keep && multiline) {
     // Not implemented. 'multiline' is only used by nvim-added messages,
@@ -335,9 +335,9 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 
   // Truncate the message if needed.
   msg_start();
-  buf = msg_strtrunc((char_u *)s, false);
+  buf = msg_strtrunc((char *)s, false);
   if (buf != NULL) {
-    s = (const char *)buf;
+    s = buf;
   }
 
   bool need_clear = true;
@@ -367,9 +367,9 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 /// @return  an allocated string or NULL when no truncating is done.
 ///
 /// @param force  always truncate
-char_u *msg_strtrunc(char_u *s, int force)
+char *msg_strtrunc(char *s, int force)
 {
-  char_u *buf = NULL;
+  char *buf = NULL;
   int len;
   int room;
 
@@ -377,7 +377,7 @@ char_u *msg_strtrunc(char_u *s, int force)
   if ((!msg_scroll && !need_wait_return && shortmess(SHM_TRUNCALL)
        && !exmode_active && msg_silent == 0 && !ui_has(kUIMessages))
       || force) {
-    len = vim_strsize((char *)s);
+    len = vim_strsize(s);
     if (msg_scrolled != 0) {
       // Use all the columns.
       room = (Rows - msg_row) * Columns - 1;
@@ -390,7 +390,7 @@ char_u *msg_strtrunc(char_u *s, int force)
       // composing chars)
       len = (room + 2) * 18;
       buf = xmalloc((size_t)len);
-      trunc_string((char *)s, (char *)buf, room, len);
+      trunc_string(s, buf, room, len);
     }
   }
   return buf;
@@ -444,7 +444,7 @@ void trunc_string(char *s, char *buf, int room_in, int buflen)
   half = i = (int)STRLEN(s);
   for (;;) {
     do {
-      half = half - utf_head_off((char_u *)s, (char_u *)s + half - 1) - 1;
+      half = half - utf_head_off(s, s + half - 1) - 1;
     } while (half > 0 && utf_iscomposing(utf_ptr2char(s + half)));
     n = ptr2cells(s + half);
     if (len + n > room || half == 0) {
@@ -900,7 +900,7 @@ char *msg_trunc_attr(char *s, bool force, int attr)
   // Add message to history before truncating.
   add_msg_hist(s, -1, attr, false);
 
-  char *ts = (char *)msg_may_trunc(force, (char_u *)s);
+  char *ts = msg_may_trunc(force, s);
 
   msg_hist_off = true;
   n = msg_attr(ts, attr);
@@ -917,14 +917,14 @@ char *msg_trunc_attr(char *s, bool force, int attr)
 /// @return  a pointer to where the truncated message starts.
 ///
 /// @note: May change the message by replacing a character with '<'.
-char_u *msg_may_trunc(bool force, char_u *s)
+char *msg_may_trunc(bool force, char *s)
 {
   int room;
 
   room = (Rows - cmdline_row - 1) * Columns + sc_col - 1;
   if ((force || (shortmess(SHM_TRUNC) && !exmode_active))
       && (int)STRLEN(s) - room > 0 && p_ch > 0) {
-    int size = vim_strsize((char *)s);
+    int size = vim_strsize(s);
 
     // There may be room anyway when there are multibyte chars.
     if (size <= room) {
@@ -932,8 +932,8 @@ char_u *msg_may_trunc(bool force, char_u *s)
     }
     int n;
     for (n = 0; size >= room;) {
-      size -= utf_ptr2cells((char *)s + n);
-      n += utfc_ptr2len((char *)s + n);
+      size -= utf_ptr2cells(s + n);
+      n += utfc_ptr2len(s + n);
     }
     n--;
     s += n;
@@ -1497,19 +1497,19 @@ void msg_outnum(long n)
   msg_puts(buf);
 }
 
-void msg_home_replace(char_u *fname)
+void msg_home_replace(char *fname)
 {
   msg_home_replace_attr(fname, 0);
 }
 
-void msg_home_replace_hl(char_u *fname)
+void msg_home_replace_hl(char *fname)
 {
   msg_home_replace_attr(fname, HL_ATTR(HLF_D));
 }
 
-static void msg_home_replace_attr(char_u *fname, int attr)
+static void msg_home_replace_attr(char *fname, int attr)
 {
-  char *name = home_replace_save(NULL, (char *)fname);
+  char *name = home_replace_save(NULL, fname);
   msg_outtrans_attr(name, attr);
   xfree(name);
 }
@@ -1526,12 +1526,12 @@ int msg_outtrans(char *str)
 
 int msg_outtrans_attr(const char *str, int attr)
 {
-  return msg_outtrans_len_attr((char_u *)str, (int)STRLEN(str), attr);
+  return msg_outtrans_len_attr(str, (int)STRLEN(str), attr);
 }
 
 int msg_outtrans_len(const char *str, int len)
 {
-  return msg_outtrans_len_attr((char_u *)str, len, 0);
+  return msg_outtrans_len_attr(str, len, 0);
 }
 
 /// Output one character at "p".
@@ -1543,19 +1543,19 @@ char *msg_outtrans_one(char *p, int attr)
   int l;
 
   if ((l = utfc_ptr2len(p)) > 1) {
-    msg_outtrans_len_attr((char_u *)p, l, attr);
+    msg_outtrans_len_attr(p, l, attr);
     return p + l;
   }
   msg_puts_attr((const char *)transchar_byte(*p), attr);
   return p + 1;
 }
 
-int msg_outtrans_len_attr(const char_u *msgstr, int len, int attr)
+int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
 {
   int retval = 0;
-  const char *str = (const char *)msgstr;
-  const char *plain_start = (const char *)msgstr;
-  char_u *s;
+  const char *str = msgstr;
+  const char *plain_start = msgstr;
+  char *s;
   int mb_l;
   int c;
   int save_got_int = got_int;
@@ -1601,7 +1601,7 @@ int msg_outtrans_len_attr(const char_u *msgstr, int len, int attr)
       len -= mb_l - 1;
       str += mb_l;
     } else {
-      s = transchar_byte((uint8_t)(*str));
+      s = (char *)transchar_byte((uint8_t)(*str));
       if (s[1] != NUL) {
         // Unprintable char: print the printable chars so far and the
         // translation of the unprintable char.
@@ -1663,12 +1663,12 @@ void msg_make(char *arg)
 ///
 /// @param from  true for LHS of a mapping
 /// @param maxlen  screen columns, 0 for unlimited
-int msg_outtrans_special(const char_u *strstart, bool from, int maxlen)
+int msg_outtrans_special(const char *strstart, bool from, int maxlen)
 {
   if (strstart == NULL) {
     return 0;  // Do nothing.
   }
-  const char_u *str = strstart;
+  const char *str = strstart;
   int retval = 0;
   int attr = HL_ATTR(HLF_8);
 
@@ -1679,7 +1679,7 @@ int msg_outtrans_special(const char_u *strstart, bool from, int maxlen)
       text = "<Space>";
       str++;
     } else {
-      text = str2special((const char **)&str, from, false);
+      text = str2special(&str, from, false);
     }
     if (text[0] != NUL && text[1] == NUL) {
       // single-byte character or illegal byte
@@ -1818,20 +1818,20 @@ void str2specialbuf(const char *sp, char *buf, size_t len)
 }
 
 /// print line for :print or :list command
-void msg_prt_line(char_u *s, int list)
+void msg_prt_line(char *s, int list)
 {
   int c;
   int col = 0;
   int n_extra = 0;
   int c_extra = 0;
   int c_final = 0;
-  char_u *p_extra = NULL;  // init to make SASC shut up
+  char *p_extra = NULL;  // init to make SASC shut up
   int n;
   int attr = 0;
-  char_u *lead = NULL;
+  char *lead = NULL;
   bool in_multispace = false;
   int multispace_pos = 0;
-  char_u *trail = NULL;
+  char *trail = NULL;
   int l;
 
   if (curwin->w_p_list) {
@@ -1873,16 +1873,16 @@ void msg_prt_line(char_u *s, int list)
         c = c_extra;
       } else {
         assert(p_extra != NULL);
-        c = *p_extra++;
+        c = (unsigned char)(*p_extra++);
       }
-    } else if ((l = utfc_ptr2len((char *)s)) > 1) {
-      col += utf_ptr2cells((char *)s);
+    } else if ((l = utfc_ptr2len(s)) > 1) {
+      col += utf_ptr2cells(s);
       char buf[MB_MAXBYTES + 1];
       if (l >= MB_MAXBYTES) {
         xstrlcpy(buf, "?", sizeof(buf));
       } else if (curwin->w_p_lcs_chars.nbsp != NUL && list
-                 && (utf_ptr2char((char *)s) == 160
-                     || utf_ptr2char((char *)s) == 0x202f)) {
+                 && (utf_ptr2char(s) == 160
+                     || utf_ptr2char(s) == 0x202f)) {
         int len = utf_char2bytes(curwin->w_p_lcs_chars.nbsp, buf);
         buf[len] = NUL;
       } else {
@@ -1894,7 +1894,7 @@ void msg_prt_line(char_u *s, int list)
       continue;
     } else {
       attr = 0;
-      c = *s++;
+      c = (unsigned char)(*s++);
       in_multispace = c == ' ' && ((col > 0 && s[-2] == ' ') || *s == ' ');
       if (!in_multispace) {
         multispace_pos = 0;
@@ -1920,7 +1920,7 @@ void msg_prt_line(char_u *s, int list)
         c = curwin->w_p_lcs_chars.nbsp;
         attr = HL_ATTR(HLF_0);
       } else if (c == NUL && list && curwin->w_p_lcs_chars.eol != NUL) {
-        p_extra = (char_u *)"";
+        p_extra = "";
         c_extra = NUL;
         c_final = NUL;
         n_extra = 1;
@@ -1929,10 +1929,10 @@ void msg_prt_line(char_u *s, int list)
         s--;
       } else if (c != NUL && (n = byte2cells(c)) > 1) {
         n_extra = n - 1;
-        p_extra = transchar_byte(c);
+        p_extra = (char *)transchar_byte(c);
         c_extra = NUL;
         c_final = NUL;
-        c = *p_extra++;
+        c = (unsigned char)(*p_extra++);
         // Use special coloring to be able to distinguish <hex> from
         // the same in plain text.
         attr = HL_ATTR(HLF_0);
@@ -2023,12 +2023,12 @@ void msg_puts_title(const char *s)
 /// Show a message in such a way that it always fits in the line.  Cut out a
 /// part in the middle and replace it with "..." when necessary.
 /// Does not handle multi-byte characters!
-void msg_outtrans_long_attr(char_u *longstr, int attr)
+void msg_outtrans_long_attr(char *longstr, int attr)
 {
   msg_outtrans_long_len_attr(longstr, (int)STRLEN(longstr), attr);
 }
 
-void msg_outtrans_long_len_attr(char_u *longstr, int len, int attr)
+void msg_outtrans_long_len_attr(char *longstr, int len, int attr)
 {
   int slen = len;
   int room;
@@ -2105,7 +2105,7 @@ void msg_puts_attr_len(const char *const str, const ptrdiff_t len, int attr)
     }
   }
   if (!msg_use_printf() || (headless_mode && default_grid.chars)) {
-    msg_puts_display((const char_u *)str, (int)len, attr, false);
+    msg_puts_display(str, (int)len, attr, false);
   }
 
   need_fileinfo = false;
@@ -2148,10 +2148,10 @@ static void msg_ext_emit_chunk(void)
 
 /// The display part of msg_puts_attr_len().
 /// May be called recursively to display scroll-back text.
-static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurse)
+static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
 {
-  const char_u *s = str;
-  const char_u *t_s = str;  // String from "t_s" to "s" is still todo.
+  const char *s = str;
+  const char *t_s = str;  // String from "t_s" to "s" is still todo.
   int t_col = 0;  // Screen cells todo, 0 when "t_s" not used.
   int l;
   int cw;
@@ -2186,19 +2186,19 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
         && (*s == '\n' || (cmdmsg_rl
                            ? (msg_col <= 1
                               || (*s == TAB && msg_col <= 7)
-                              || (utf_ptr2cells((char *)s) > 1
+                              || (utf_ptr2cells(s) > 1
                                   && msg_col <= 2))
                            : ((*s != '\r' && msg_col + t_col >= Columns - 1)
                               || (*s == TAB
                                   && msg_col + t_col >= ((Columns - 1) & ~7))
-                              || (utf_ptr2cells((char *)s) > 1
+                              || (utf_ptr2cells(s) > 1
                                   && msg_col + t_col >= Columns - 2))))) {
       // The screen is scrolled up when at the last row (some terminals
       // scroll automatically, some don't.  To avoid problems we scroll
       // ourselves).
       if (t_col > 0) {
         // output postponed text
-        t_puts(&t_col, (char *)t_s, (char *)s, attr);
+        t_puts(&t_col, t_s, s, attr);
       }
 
       // When no more prompt and no more room, truncate here
@@ -2207,7 +2207,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       }
 
       // Scroll the screen up one line.
-      bool has_last_char = (*s >= ' ' && !cmdmsg_rl);
+      bool has_last_char = ((uint8_t)(*s) >= ' ' && !cmdmsg_rl);
       msg_scroll_up(!has_last_char);
 
       msg_row = Rows - 2;
@@ -2219,11 +2219,11 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       if (has_last_char) {
         if (maxlen >= 0) {
           // Avoid including composing chars after the end.
-          l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
+          l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
         } else {
-          l = utfc_ptr2len((char *)s);
+          l = utfc_ptr2len(s);
         }
-        s = (char_u *)screen_puts_mbyte((char *)s, l, attr);
+        s = screen_puts_mbyte((char *)s, l, attr);
         did_last_char = true;
       } else {
         did_last_char = false;
@@ -2276,13 +2276,13 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
     wrap = *s == '\n'
            || msg_col + t_col >= Columns
-           || (utf_ptr2cells((char *)s) > 1
+           || (utf_ptr2cells(s) > 1
                && msg_col + t_col >= Columns - 1)
     ;
     if (t_col > 0 && (wrap || *s == '\r' || *s == '\b'
                       || *s == '\t' || *s == BELL)) {
       // Output any postponed text.
-      t_puts(&t_col, (char *)t_s, (char *)s, attr);
+      t_puts(&t_col, t_s, s, attr);
     }
 
     if (wrap && p_more && !recurse) {
@@ -2312,20 +2312,20 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       } while (msg_col & 7);
     } else if (*s == BELL) {  // beep (from ":sh")
       vim_beep(BO_SH);
-    } else if (*s >= 0x20) {  // printable char
-      cw = utf_ptr2cells((char *)s);
+    } else if ((uint8_t)(*s) >= 0x20) {  // printable char
+      cw = utf_ptr2cells(s);
       if (maxlen >= 0) {
         // avoid including composing chars after the end
-        l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
+        l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
       } else {
-        l = utfc_ptr2len((char *)s);
+        l = utfc_ptr2len(s);
       }
       // When drawing from right to left or when a double-wide character
       // doesn't fit, draw a single character here.  Otherwise collect
       // characters and draw them all at once later.
       if (cmdmsg_rl || (cw > 1 && msg_col + t_col >= Columns - 1)) {
         if (l > 1) {
-          s = (char_u *)screen_puts_mbyte((char *)s, l, attr) - 1;
+          s = screen_puts_mbyte((char *)s, l, attr) - 1;
         } else {
           msg_screen_putchar(*s, attr);
         }
@@ -2343,7 +2343,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
   // Output any postponed text.
   if (t_col > 0) {
-    t_puts(&t_col, (char *)t_s, (char *)s, attr);
+    t_puts(&t_col, t_s, s, attr);
   }
   if (p_more && !recurse) {
     store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, false);
@@ -2679,7 +2679,7 @@ void msg_sb_eol(void)
 static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp)
 {
   msgchunk_T *mp = smp;
-  char_u *p;
+  char *p;
 
   for (;;) {
     msg_row = row;
@@ -3080,13 +3080,13 @@ static void msg_screen_putchar(int c, int attr)
 void msg_moremsg(int full)
 {
   int attr;
-  char_u *s = (char_u *)_("-- More --");
+  char *s = _("-- More --");
 
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), HL_ATTR(HLF_M));
-  grid_puts(&msg_grid_adj, (char *)s, Rows - 1, 0, attr);
+  grid_puts(&msg_grid_adj, s, Rows - 1, 0, attr);
   if (full) {
     grid_puts(&msg_grid_adj, _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
-              Rows - 1, vim_strsize((char *)s), attr);
+              Rows - 1, vim_strsize(s), attr);
   }
 }
 
@@ -3281,7 +3281,7 @@ void msg_check(void)
 /// @param maxlen  if -1, write the whole string, otherwise up to "maxlen" bytes.
 static void redir_write(const char *const str, const ptrdiff_t maxlen)
 {
-  const char_u *s = (char_u *)str;
+  const char *s = str;
   static int cur_col = 0;
 
   if (maxlen == 0) {
@@ -3306,7 +3306,7 @@ static void redir_write(const char *const str, const ptrdiff_t maxlen)
           ga_concat_len(capture_ga, " ", 1);
         }
         if (redir_reg) {
-          write_reg_contents(redir_reg, (char_u *)" ", 1, true);
+          write_reg_contents(redir_reg, " ", 1, true);
         } else if (redir_vname) {
           var_redir_str(" ", -1);
         } else if (redir_fd != NULL) {
@@ -3332,7 +3332,7 @@ static void redir_write(const char *const str, const ptrdiff_t maxlen)
 
     // Write and adjust the current column.
     while (*s != NUL
-           && (maxlen < 0 || (int)(s - (const char_u *)str) < maxlen)) {
+           && (maxlen < 0 || (int)(s - str) < maxlen)) {
       if (!redir_reg && !redir_vname && !capture_ga) {
         if (redir_fd != NULL) {
           putc(*s, redir_fd);
@@ -3469,9 +3469,9 @@ void give_warning(char *message, bool hl)
   no_wait_return--;
 }
 
-void give_warning2(char_u *const message, char_u *const a1, bool hl)
+void give_warning2(char *const message, char *const a1, bool hl)
 {
-  vim_snprintf((char *)IObuff, IOSIZE, (char *)message, a1);
+  vim_snprintf((char *)IObuff, IOSIZE, message, a1);
   give_warning((char *)IObuff, hl);
 }
 
@@ -3524,11 +3524,11 @@ void msg_advance(int col)
 /// @param textfiel  IObuff for inputdialog(), NULL otherwise
 /// @param ex_cmd  when true pressing : accepts default and starts Ex command
 /// @returns 0 if cancelled, otherwise the nth button (1-indexed).
-int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton,
-              char_u *textfield, int ex_cmd)
+int do_dialog(int type, char *title, char *message, char *buttons, int dfltbutton, char *textfield,
+              int ex_cmd)
 {
   int retval = 0;
-  char_u *hotkeys;
+  char *hotkeys;
   int c;
   int i;
 
@@ -3578,10 +3578,10 @@ int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfl
       c = mb_tolower(c);
       retval = 1;
       for (i = 0; hotkeys[i]; i++) {
-        if (utf_ptr2char((char *)hotkeys + i) == c) {
+        if (utf_ptr2char(hotkeys + i) == c) {
           break;
         }
-        i += utfc_ptr2len((char *)hotkeys + i) - 1;
+        i += utfc_ptr2len(hotkeys + i) - 1;
         retval++;
       }
       if (hotkeys[i]) {
@@ -3608,14 +3608,14 @@ int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfl
 /// characters.  Return the length of the character in bytes.
 ///
 /// @param lowercase  make character lower case
-static int copy_char(const char_u *from, char_u *to, bool lowercase)
+static int copy_char(const char *from, char *to, bool lowercase)
   FUNC_ATTR_NONNULL_ALL
 {
   if (lowercase) {
-    int c = mb_tolower(utf_ptr2char((char *)from));
-    return utf_char2bytes(c, (char *)to);
+    int c = mb_tolower(utf_ptr2char(from));
+    return utf_char2bytes(c, to);
   }
-  int len = utfc_ptr2len((char *)from);
+  int len = utfc_ptr2len(from);
   memmove(to, from, (size_t)len);
   return len;
 }
@@ -3635,7 +3635,7 @@ static int copy_char(const char_u *from, char_u *to, bool lowercase)
 ///                        corresponding button has a hotkey
 ///
 /// @return Pointer to memory allocated for storing hotkeys
-static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool has_hotkey[])
+static char *console_dialog_alloc(const char *message, char *buttons, bool has_hotkey[])
 {
   int lenhotkey = HOTK_LEN;  // count first button
   has_hotkey[0] = false;
@@ -3643,7 +3643,7 @@ static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool
   // Compute the size of memory to allocate.
   int len = 0;
   int idx = 0;
-  char_u *r = buttons;
+  char *r = buttons;
   while (*r) {
     if (*r == DLG_BUTTON_SEP) {
       len += 3;                         // '\n' -> ', '; 'x' -> '(x)'
@@ -3689,11 +3689,11 @@ static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool
 /// The hotkeys can be multi-byte characters, but without combining chars.
 ///
 /// @return  an allocated string with hotkeys.
-static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfltbutton)
+static char *msg_show_console_dialog(char *message, char *buttons, int dfltbutton)
   FUNC_ATTR_NONNULL_RET
 {
   bool has_hotkey[HAS_HOTKEY_LEN] = { false };
-  char_u *hotk = console_dialog_alloc(message, buttons, has_hotkey);
+  char *hotk = console_dialog_alloc(message, buttons, has_hotkey);
 
   copy_hotkeys_and_msg(message, buttons, dfltbutton, has_hotkey, hotk);
 
@@ -3709,13 +3709,13 @@ static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfl
 /// @param has_hotkey An element in this array is true if corresponding button
 ///                   has a hotkey
 /// @param[out] hotkeys_ptr Pointer to the memory location where hotkeys will be copied
-static void copy_hotkeys_and_msg(const char_u *message, char_u *buttons, int default_button_idx,
-                                 const bool has_hotkey[], char_u *hotkeys_ptr)
+static void copy_hotkeys_and_msg(const char *message, char *buttons, int default_button_idx,
+                                 const bool has_hotkey[], char *hotkeys_ptr)
 {
   *confirm_msg = '\n';
   STRCPY(confirm_msg + 1, message);
 
-  char_u *msgp = confirm_msg + 1 + STRLEN(message);
+  char *msgp = confirm_msg + 1 + STRLEN(message);
 
   // Define first default hotkey. Keep the hotkey string NUL
   // terminated to avoid reading past the end.
@@ -3732,7 +3732,7 @@ static void copy_hotkeys_and_msg(const char_u *message, char_u *buttons, int def
   }
 
   int idx = 0;
-  char_u *r = buttons;
+  char *r = buttons;
   while (*r) {
     if (*r == DLG_BUTTON_SEP) {
       *msgp++ = ',';
@@ -3788,28 +3788,28 @@ void display_confirm_msg(void)
   confirm_msg_used++;
   if (confirm_msg != NULL) {
     msg_ext_set_kind("confirm");
-    msg_puts_attr((const char *)confirm_msg, HL_ATTR(HLF_M));
+    msg_puts_attr(confirm_msg, HL_ATTR(HLF_M));
   }
   confirm_msg_used--;
 }
 
-int vim_dialog_yesno(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesno(int type, char *title, char *message, int dflt)
 {
   if (do_dialog(type,
-                title == NULL ? (char_u *)_("Question") : title,
+                title == NULL ? _("Question") : title,
                 message,
-                (char_u *)_("&Yes\n&No"), dflt, NULL, false) == 1) {
+                _("&Yes\n&No"), dflt, NULL, false) == 1) {
     return VIM_YES;
   }
   return VIM_NO;
 }
 
-int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesnocancel(int type, char *title, char *message, int dflt)
 {
   switch (do_dialog(type,
-                    title == NULL ? (char_u *)_("Question") : title,
+                    title == NULL ? _("Question") : title,
                     message,
-                    (char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, false)) {
+                    _("&Yes\n&No\n&Cancel"), dflt, NULL, false)) {
   case 1:
     return VIM_YES;
   case 2:
@@ -3818,12 +3818,12 @@ int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt)
   return VIM_CANCEL;
 }
 
-int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesnoallcancel(int type, char *title, char *message, int dflt)
 {
   switch (do_dialog(type,
-                    title == NULL ? (char_u *)"Question" : title,
+                    title == NULL ? "Question" : title,
                     message,
-                    (char_u *)_("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
+                    _("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
                     dflt, NULL, false)) {
   case 1:
     return VIM_YES;
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 73147204a1..90084bde17 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -633,7 +633,7 @@ colnr_T vcol2col(win_T *const wp, const linenr_T lnum, const colnr_T vcol)
   // try to advance to the specified column
   char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   while (cts.cts_vcol < vcol && *cts.cts_ptr != NUL) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
     MB_PTR_ADV(cts.cts_ptr);
@@ -666,7 +666,7 @@ void set_mouse_topline(win_T *wp)
 static colnr_T scroll_line_len(linenr_T lnum)
 {
   colnr_T col = 0;
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   if (*line != NUL) {
     for (;;) {
       int numchar = win_chartabsize(curwin, (char *)line, col);
@@ -771,7 +771,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
   // highlighting the second byte, not the ninth.
 
   linenr_T lnum = wp->w_cursor.lnum;
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   char_u *ptr = line;
   char_u *ptr_end;
   char_u *ptr_row_offset = line;  // Where we begin adjusting `ptr_end`
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 47ad000385..17b79e27c1 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2215,12 +2215,12 @@ static void find_start_of_word(pos_T *pos)
   int cclass;
   int col;
 
-  line = ml_get(pos->lnum);
+  line = (char_u *)ml_get(pos->lnum);
   cclass = get_mouse_class(line + pos->col);
 
   while (pos->col > 0) {
     col = pos->col - 1;
-    col -= utf_head_off(line, line + col);
+    col -= utf_head_off((char *)line, (char *)line + col);
     if (get_mouse_class(line + col) != cclass) {
       break;
     }
@@ -2236,10 +2236,10 @@ static void find_end_of_word(pos_T *pos)
   int cclass;
   int col;
 
-  line = ml_get(pos->lnum);
+  line = (char_u *)ml_get(pos->lnum);
   if (*p_sel == 'e' && pos->col > 0) {
     pos->col--;
-    pos->col -= utf_head_off(line, line + pos->col);
+    pos->col -= utf_head_off((char *)line, (char *)line + pos->col);
   }
   cclass = get_mouse_class(line + pos->col);
   while (line[pos->col] != NUL) {
@@ -2445,7 +2445,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
       this_class = mb_get_class(ptr + col);
     }
     while (col > 0 && this_class != 0) {
-      prevcol = col - 1 - utf_head_off(ptr, ptr + col - 1);
+      prevcol = col - 1 - utf_head_off((char *)ptr, (char *)ptr + col - 1);
       prev_class = mb_get_class(ptr + prevcol);
       if (this_class != prev_class
           && (i == 0
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 4f2b84d20f..adb071b754 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -272,7 +272,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
     // Set "'[" and "']" marks.
     curbuf->b_op_start = oap->start;
     curbuf->b_op_end.lnum = oap->end.lnum;
-    curbuf->b_op_end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+    curbuf->b_op_end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
     if (curbuf->b_op_end.col > 0) {
       curbuf->b_op_end.col--;
     }
@@ -382,7 +382,7 @@ static void shift_block(oparg_T *oap, int amount)
     // TODO(vim): is passing bd.textstart for start of the line OK?
     chartabsize_T cts;
     init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
-                         bd.start_vcol, bd.textstart, bd.textstart);
+                         bd.start_vcol, (char *)bd.textstart, (char *)bd.textstart);
     while (ascii_iswhite(*cts.cts_ptr)) {
       incr = lbr_chartabsize_adv(&cts);
       total += incr;
@@ -448,7 +448,7 @@ static void shift_block(oparg_T *oap, int amount)
 
     chartabsize_T cts;
     init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
-                         non_white_col, bd.textstart, non_white);
+                         non_white_col, (char *)bd.textstart, (char *)non_white);
     while (ascii_iswhite(*cts.cts_ptr)) {
       incr = lbr_chartabsize_adv(&cts);
       cts.cts_vcol += incr;
@@ -477,7 +477,7 @@ static void shift_block(oparg_T *oap, int amount)
       verbatim_copy_width -= bd.start_char_vcols;
     }
     init_chartabsize_arg(&cts, curwin, 0, verbatim_copy_width,
-                         bd.textstart, verbatim_copy_end);
+                         (char *)bd.textstart, (char *)verbatim_copy_end);
     while (cts.cts_vcol < destination_col) {
       incr = lbr_chartabsize(&cts);
       if (cts.cts_vcol + incr > destination_col) {
@@ -543,7 +543,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
       continue;  // OP_INSERT, line ends before block start
     }
 
-    oldp = ml_get(lnum);
+    oldp = (char_u *)ml_get(lnum);
 
     if (b_insert) {
       ts_val = bdp->start_char_vcols;
@@ -572,7 +572,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
 
     if (spaces > 0) {
       // avoid copying part of a multi-byte character
-      offset -= utf_head_off(oldp, oldp + offset);
+      offset -= utf_head_off((char *)oldp, (char *)oldp + offset);
     }
     if (spaces < 0) {  // can happen when the cursor was moved
       spaces = 0;
@@ -1014,7 +1014,7 @@ static int stuff_yank(int regname, char_u *p)
   yankreg_T *reg = get_yank_register(regname, YREG_YANK);
   if (is_append_register(regname) && reg->y_array != NULL) {
     char **pp = &(reg->y_array[reg->y_size - 1]);
-    char_u *lp = xmalloc(STRLEN(*pp) + STRLEN(p) + 1);
+    char_u *lp = xmalloc(strlen(*pp) + STRLEN(p) + 1);
     STRCPY(lp, *pp);
     // TODO(philix): use xstpcpy() in stuff_yank()
     STRCAT(lp, p);
@@ -1513,7 +1513,7 @@ int op_delete(oparg_T *oap)
       && oap->line_count > 1
       && oap->motion_force == NUL
       && oap->op_type == OP_DELETE) {
-    ptr = ml_get(oap->end.lnum) + oap->end.col;
+    ptr = (char_u *)ml_get(oap->end.lnum) + oap->end.col;
     if (*ptr != NUL) {
       ptr += oap->inclusive;
     }
@@ -1617,7 +1617,7 @@ int op_delete(oparg_T *oap)
       // If we delete a TAB, it may be replaced by several characters.
       // Thus the number of characters may increase!
       n = bd.textlen - bd.startspaces - bd.endspaces;
-      oldp = ml_get(lnum);
+      oldp = (char_u *)ml_get(lnum);
       newp = (char_u *)xmalloc(STRLEN(oldp) - (size_t)n + 1);
       // copy up to deleted part
       memmove(newp, oldp, (size_t)bd.textcol);
@@ -1662,7 +1662,7 @@ int op_delete(oparg_T *oap)
         beginline(0);                       // cursor in column 0
       }
 
-      int old_len = (int)STRLEN(ml_get(curwin->w_cursor.lnum));
+      int old_len = (int)strlen(ml_get(curwin->w_cursor.lnum));
       truncate_line(false);         // delete the rest of the line
 
       extmark_splice_cols(curbuf,
@@ -1816,7 +1816,7 @@ setmarks:
 static void mb_adjust_opend(oparg_T *oap)
 {
   if (oap->inclusive) {
-    char *p = (char *)ml_get(oap->end.lnum);
+    char *p = ml_get(oap->end.lnum);
     oap->end.col += utf_cp_tail_off(p, p + oap->end.col);
   }
 }
@@ -1990,7 +1990,7 @@ static int op_replace(oparg_T *oap, int c)
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
       curwin->w_cursor.col = 0;
-      oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+      oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
       if (oap->end.col) {
         oap->end.col--;
       }
@@ -2104,7 +2104,7 @@ void op_tilde(oparg_T *oap)
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
       pos.col = 0;
-      oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+      oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
       if (oap->end.col) {
         oap->end.col--;
       }
@@ -2281,7 +2281,7 @@ void op_insert(oparg_T *oap, long count1)
     // Get indent information
     ind_pre_col = (colnr_T)getwhitecols_curline();
     ind_pre_vcol = get_indent();
-    firstline = ml_get(oap->start.lnum) + bd.textcol;
+    firstline = (char_u *)ml_get(oap->start.lnum) + bd.textcol;
 
     if (oap->op_type == OP_APPEND) {
       firstline += bd.textlen;
@@ -2413,7 +2413,7 @@ void op_insert(oparg_T *oap, long count1)
      * Subsequent calls to ml_get() flush the firstline data - take a
      * copy of the required string.
      */
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     const size_t len = STRLEN(firstline);
     colnr_T add = bd.textcol;
     colnr_T offset = 0;  // offset when cursor was moved in insert mode
@@ -2498,7 +2498,7 @@ int op_change(oparg_T *oap)
                        || gchar_cursor() == NUL)) {
       coladvance_force(getviscol());
     }
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     pre_textlen = (long)STRLEN(firstline);
     pre_indent = (long)getwhitecols((char *)firstline);
     bd.textcol = curwin->w_cursor.col;
@@ -2519,7 +2519,7 @@ int op_change(oparg_T *oap)
       && oap->start.lnum != oap->end.lnum && !got_int) {
     // Auto-indenting may have changed the indent.  If the cursor was past
     // the indent, exclude that indent change from the inserted text.
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     if (bd.textcol > (colnr_T)pre_indent) {
       long new_indent = (long)getwhitecols((char *)firstline);
 
@@ -2547,7 +2547,7 @@ int op_change(oparg_T *oap)
           } else {
             vpos.coladd = 0;
           }
-          oldp = ml_get(linenr);
+          oldp = (char_u *)ml_get(linenr);
           newp = xmalloc(STRLEN(oldp) + (size_t)vpos.coladd
                          + (size_t)ins_len + 1);
           // copy up to block start
@@ -2691,14 +2691,14 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
       break;
 
     case kMTLineWise:
-      reg->y_array[y_idx] = (char *)vim_strsave(ml_get(lnum));
+      reg->y_array[y_idx] = xstrdup(ml_get(lnum));
       break;
 
     case kMTCharWise: {
       colnr_T startcol = 0, endcol = MAXCOL;
       int is_oneChar = false;
       colnr_T cs, ce;
-      p = ml_get(lnum);
+      p = (char_u *)ml_get(lnum);
       bd.startspaces = 0;
       bd.endspaces = 0;
 
@@ -2724,7 +2724,7 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
                                    // Don't add space for double-wide
                                    // char; endcol will be on last byte
                                    // of multi-byte char.
-                                   && utf_head_off(p, p + endcol) == 0)) {
+                                   && utf_head_off((char *)p, (char *)p + endcol) == 0)) {
             if (oap->start.lnum == oap->end.lnum
                 && oap->start.col == oap->end.col) {
               // Special case: inside a single char
@@ -2776,8 +2776,8 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
     // the new block, unless being Vi compatible.
     if (curr->y_type == kMTCharWise
         && vim_strchr(p_cpo, CPO_REGAPPEND) == NULL) {
-      pnew = xmalloc(STRLEN(curr->y_array[curr->y_size - 1])
-                     + STRLEN(reg->y_array[0]) + 1);
+      pnew = xmalloc(strlen(curr->y_array[curr->y_size - 1])
+                     + strlen(reg->y_array[0]) + 1);
       STRCPY(pnew, curr->y_array[--j]);
       STRCAT(pnew, reg->y_array[0]);
       xfree(curr->y_array[j]);
@@ -2857,7 +2857,7 @@ static void yank_copy_line(yankreg_T *reg, struct block_def *bd, size_t y_idx,
     int s = bd->textlen + bd->endspaces;
 
     while (s > 0 && ascii_iswhite(*(bd->textstart + s - 1))) {
-      s = s - utf_head_off(bd->textstart, bd->textstart + s - 1) - 1;
+      s = s - utf_head_off((char *)bd->textstart, (char *)bd->textstart + s - 1) - 1;
       pnew--;
     }
   }
@@ -3299,7 +3299,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       oldlen = STRLEN(oldp);
       chartabsize_T cts;
       init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0,
-                           oldp, oldp);
+                           (char *)oldp, (char *)oldp);
 
       while (cts.cts_vcol < col && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
@@ -3320,7 +3320,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         bd.startspaces = incr - bd.endspaces;
         bd.textcol--;
         delcount = 1;
-        bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
+        bd.textcol -= utf_head_off((char *)oldp, (char *)oldp + bd.textcol);
         if (oldp[bd.textcol] != TAB) {
           /* Only a Tab can be split into spaces.  Other
            * characters will have to be moved to after the
@@ -3336,8 +3336,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         // calculate number of spaces required to fill right side of
         // block
         spaces = y_width + 1;
-        init_chartabsize_arg(&cts, curwin, 0, 0,
-                             (char_u *)y_array[i], (char_u *)y_array[i]);
+        init_chartabsize_arg(&cts, curwin, 0, 0, y_array[i], y_array[i]);
         for (int j = 0; j < yanklen; j++) {
           spaces -= lbr_chartabsize(&cts);
           cts.cts_ptr++;
@@ -3483,7 +3482,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       } else {
         totlen = (size_t)(count * yanklen);
         do {
-          oldp = ml_get(lnum);
+          oldp = (char_u *)ml_get(lnum);
           oldlen = STRLEN(oldp);
           if (lnum > start_lnum) {
             pos_T pos = {
@@ -3510,7 +3509,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           ml_replace(lnum, (char *)newp, false);
 
           // compute the byte offset for the last character
-          first_byte_off = utf_head_off(newp, ptr - 1);
+          first_byte_off = utf_head_off((char *)newp, (char *)ptr - 1);
 
           // Place cursor on last putted char.
           if (lnum == curwin->w_cursor.lnum) {
@@ -3554,7 +3553,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           // First insert y_array[size - 1] in front of second line.
           // Then append y_array[0] to first line.
           lnum = new_cursor.lnum;
-          ptr = ml_get(lnum) + col;
+          ptr = (char_u *)ml_get(lnum) + col;
           totlen = STRLEN(y_array[y_size - 1]);
           newp = (char_u *)xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
           STRCPY(newp, y_array[y_size - 1]);
@@ -3564,7 +3563,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           new_lnum++;
           xfree(newp);
 
-          oldp = ml_get(lnum);
+          oldp = (char_u *)ml_get(lnum);
           newp = (char_u *)xmalloc((size_t)col + (size_t)yanklen + 1);
           // copy first part of line
           memmove(newp, oldp, (size_t)col);
@@ -3588,7 +3587,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           if (flags & PUT_FIXINDENT) {
             old_pos = curwin->w_cursor;
             curwin->w_cursor.lnum = lnum;
-            ptr = ml_get(lnum);
+            ptr = (char_u *)ml_get(lnum);
             if (cnt == count && i == y_size - 1) {
               lendiff = (int)STRLEN(ptr);
             }
@@ -3668,8 +3667,8 @@ error:
       if (col > 1) {
         curbuf->b_op_end.col = col - 1;
         if (len > 0) {
-          curbuf->b_op_end.col -= utf_head_off((char_u *)y_array[y_size - 1],
-                                               (char_u *)y_array[y_size - 1] + len - 1);
+          curbuf->b_op_end.col -= utf_head_off(y_array[y_size - 1],
+                                               y_array[y_size - 1] + len - 1);
         }
       } else {
         curbuf->b_op_end.col = 0;
@@ -3878,14 +3877,14 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '.') != NULL) && !got_int
       && !message_filtered((char *)p)) {
     msg_puts("\n  c  \".   ");
-    dis_msg(p, true);
+    dis_msg((char *)p, true);
   }
 
   // display last command line
   if (last_cmdline != NULL && (arg == NULL || vim_strchr((char *)arg, ':') != NULL)
       && !got_int && !message_filtered(last_cmdline)) {
     msg_puts("\n  c  \":   ");
-    dis_msg((char_u *)last_cmdline, false);
+    dis_msg(last_cmdline, false);
   }
 
   // display current file name
@@ -3893,7 +3892,7 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '%') != NULL) && !got_int
       && !message_filtered(curbuf->b_fname)) {
     msg_puts("\n  c  \"%   ");
-    dis_msg((char_u *)curbuf->b_fname, false);
+    dis_msg(curbuf->b_fname, false);
   }
 
   // display alternate file name
@@ -3903,7 +3902,7 @@ void ex_display(exarg_T *eap)
 
     if (buflist_name_nr(0, &fname, &dummy) != FAIL && !message_filtered(fname)) {
       msg_puts("\n  c  \"#   ");
-      dis_msg((char_u *)fname, false);
+      dis_msg(fname, false);
     }
   }
 
@@ -3912,14 +3911,14 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '/') != NULL) && !got_int
       && !message_filtered((char *)last_search_pat())) {
     msg_puts("\n  c  \"/   ");
-    dis_msg(last_search_pat(), false);
+    dis_msg((char *)last_search_pat(), false);
   }
 
   // display last used expression
   if (expr_line != NULL && (arg == NULL || vim_strchr((char *)arg, '=') != NULL)
       && !got_int && !message_filtered((char *)expr_line)) {
     msg_puts("\n  c  \"=   ");
-    dis_msg(expr_line, false);
+    dis_msg((char *)expr_line, false);
   }
 }
 
@@ -3927,7 +3926,7 @@ void ex_display(exarg_T *eap)
 /// truncate at end of screen line
 ///
 /// @param skip_esc  if true, ignore trailing ESC
-static void dis_msg(const char_u *p, bool skip_esc)
+static void dis_msg(const char *p, bool skip_esc)
   FUNC_ATTR_NONNULL_ALL
 {
   int n;
@@ -3936,12 +3935,12 @@ static void dis_msg(const char_u *p, bool skip_esc)
   n = Columns - 6;
   while (*p != NUL
          && !(*p == ESC && skip_esc && *(p + 1) == NUL)
-         && (n -= ptr2cells((char *)p)) >= 0) {
-    if ((l = utfc_ptr2len((char *)p)) > 1) {
-      msg_outtrans_len((char *)p, l);
+         && (n -= ptr2cells(p)) >= 0) {
+    if ((l = utfc_ptr2len(p)) > 1) {
+      msg_outtrans_len(p, l);
       p += l;
     } else {
-      msg_outtrans_len((char *)p++, 1);
+      msg_outtrans_len(p++, 1);
     }
   }
   os_breakcheck();
@@ -3958,11 +3957,11 @@ static void dis_msg(const char_u *p, bool skip_esc)
 /// @param include_space - whether to skip space following the comment leader
 /// @param[out] is_comment - whether the current line ends with an unclosed
 ///  comment.
-char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_comment)
+char *skip_comment(char *line, bool process, bool include_space, bool *is_comment)
 {
   char *comment_flags = NULL;
   int lead_len;
-  int leader_offset = get_last_leader_offset((char *)line, &comment_flags);
+  int leader_offset = get_last_leader_offset(line, &comment_flags);
 
   *is_comment = false;
   if (leader_offset != -1) {
@@ -3984,7 +3983,7 @@ char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_co
     return line;
   }
 
-  lead_len = get_leader_len((char *)line, &comment_flags, false, include_space);
+  lead_len = get_leader_len(line, &comment_flags, false, include_space);
 
   if (lead_len == 0) {
     return line;
@@ -4022,11 +4021,11 @@ char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_co
 /// @return  FAIL for failure, OK otherwise
 int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions, bool setmark)
 {
-  char_u *curr = NULL;
-  char_u *curr_start = NULL;
-  char_u *cend;
-  char_u *newp;
-  char_u *spaces;          // number of spaces inserted before a line
+  char *curr = NULL;
+  char *curr_start = NULL;
+  char *cend;
+  char *newp;
+  char *spaces;          // number of spaces inserted before a line
   int endcurr1 = NUL;
   int endcurr2 = NUL;
   int currsize = 0;             // size of the current line
@@ -4055,7 +4054,8 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   // Don't move anything, just compute the final line length
   // and setup the array of space strings lengths
   for (t = 0; t < (linenr_T)count; t++) {
-    curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
+    curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
+    curr = curr_start;
     if (t == 0 && setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
       // Set the '[ mark.
       curwin->w_buffer->b_op_start.lnum = curwin->w_cursor.lnum;
@@ -4065,8 +4065,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
       // We don't want to remove the comment leader if the
       // previous line is not a comment.
       if (t > 0 && prev_was_comment) {
-        char_u *new_curr = skip_comment(curr, true, insert_space,
-                                        &prev_was_comment);
+        char *new_curr = skip_comment(curr, true, insert_space, &prev_was_comment);
         comments[t] = (int)(new_curr - curr);
         curr = new_curr;
       } else {
@@ -4075,17 +4074,17 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
     }
 
     if (insert_space && t > 0) {
-      curr = (char_u *)skipwhite((char *)curr);
+      curr = skipwhite(curr);
       if (*curr != NUL
           && *curr != ')'
           && sumsize != 0
           && endcurr1 != TAB
           && (!has_format_option(FO_MBYTE_JOIN)
-              || (utf_ptr2char((char *)curr) < 0x100 && endcurr1 < 0x100))
+              || (utf_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
           && (!has_format_option(FO_MBYTE_JOIN2)
-              || (utf_ptr2char((char *)curr) < 0x100 && !utf_eat_space(endcurr1))
+              || (utf_ptr2char(curr) < 0x100 && !utf_eat_space(endcurr1))
               || (endcurr1 < 0x100
-                  && !utf_eat_space(utf_ptr2char((char *)curr))))) {
+                  && !utf_eat_space(utf_ptr2char(curr))))) {
         // don't add a space if the line is ending in a space
         if (endcurr1 == ' ') {
           endcurr1 = endcurr2;
@@ -4112,10 +4111,10 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
     if (insert_space && currsize > 0) {
       cend = curr + currsize;
       MB_PTR_BACK(curr, cend);
-      endcurr1 = utf_ptr2char((char *)cend);
+      endcurr1 = utf_ptr2char(cend);
       if (cend > curr) {
         MB_PTR_BACK(curr, cend);
-        endcurr2 = utf_ptr2char((char *)cend);
+        endcurr2 = utf_ptr2char(cend);
       }
     }
     line_breakcheck();
@@ -4129,7 +4128,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   col = sumsize - currsize - spaces[count - 1];
 
   // allocate the space for the new line
-  newp = (char_u *)xmalloc((size_t)sumsize + 1);
+  newp = xmalloc((size_t)sumsize + 1);
   cend = newp + sumsize;
   *cend = 0;
 
@@ -4165,17 +4164,18 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
       break;
     }
 
-    curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1));
+    curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1));
+    curr = curr_start;
     if (remove_comments) {
       curr += comments[t - 1];
     }
     if (insert_space && t > 1) {
-      curr = (char_u *)skipwhite((char *)curr);
+      curr = skipwhite(curr);
     }
     currsize = (int)STRLEN(curr);
   }
 
-  ml_replace(curwin->w_cursor.lnum, (char *)newp, false);
+  ml_replace(curwin->w_cursor.lnum, newp, false);
 
   if (setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
     // Set the '] mark.
@@ -4234,11 +4234,11 @@ theend:
 static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool is_del)
 {
   int incr = 0;
-  char_u *pend;
-  char_u *pstart;
-  char_u *line;
-  char_u *prev_pstart;
-  char_u *prev_pend;
+  char *pend;
+  char *pstart;
+  char *line;
+  char *prev_pstart;
+  char *prev_pend;
   const int lbr_saved = curwin->w_p_lbr;
 
   // Avoid a problem with unwanted linebreaks in block mode.
@@ -4271,11 +4271,11 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
       bdp->pre_whitesp = 0;
       bdp->pre_whitesp_c = 0;
     }
-    prev_pstart = (char_u *)cts.cts_ptr;
+    prev_pstart = cts.cts_ptr;
     MB_PTR_ADV(cts.cts_ptr);
   }
   bdp->start_vcol = cts.cts_vcol;
-  pstart = (char_u *)cts.cts_ptr;
+  pstart = cts.cts_ptr;
   clear_chartabsize_arg(&cts);
 
   bdp->start_char_vcols = incr;
@@ -4313,17 +4313,16 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
         }
       }
     } else {
-      init_chartabsize_arg(&cts, curwin, lnum, bdp->end_vcol,
-                           line, pend);
+      init_chartabsize_arg(&cts, curwin, lnum, bdp->end_vcol, line, pend);
       prev_pend = pend;
       while (cts.cts_vcol <= oap->end_vcol && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
-        prev_pend = (char_u *)cts.cts_ptr;
+        prev_pend = cts.cts_ptr;
         incr = lbr_chartabsize_adv(&cts);
         cts.cts_vcol += incr;
       }
       bdp->end_vcol = cts.cts_vcol;
-      pend = (char_u *)cts.cts_ptr;
+      pend = cts.cts_ptr;
       clear_chartabsize_arg(&cts);
 
       if (bdp->end_vcol <= oap->end_vcol
@@ -4356,7 +4355,7 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
     bdp->textlen = (int)(pend - pstart);
   }
   bdp->textcol = (colnr_T)(pstart - line);
-  bdp->textstart = pstart;
+  bdp->textstart = (char_u *)pstart;
   curwin->w_p_lbr = lbr_saved;
 }
 
@@ -4511,7 +4510,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
   }
 
   curwin->w_cursor = *pos;
-  ptr = ml_get(pos->lnum);
+  ptr = (char_u *)ml_get(pos->lnum);
   col = pos->col;
 
   if (*ptr == NUL || col + !!save_coladd >= (int)STRLEN(ptr)) {
@@ -4523,14 +4522,14 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     if (do_bin) {
       while (col > 0 && ascii_isbdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
 
     if (do_hex) {
       while (col > 0 && ascii_isxdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
     if (do_bin
@@ -4538,7 +4537,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
         && !((col > 0
               && (ptr[col] == 'X' || ptr[col] == 'x')
               && ptr[col - 1] == '0'
-              && !utf_head_off(ptr, ptr + col - 1)
+              && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
               && ascii_isxdigit(ptr[col + 1])))) {
       // In case of binary/hexadecimal pattern overlap match, rescan
 
@@ -4546,7 +4545,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
 
       while (col > 0 && ascii_isdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
 
@@ -4554,17 +4553,17 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
          && col > 0
          && (ptr[col] == 'X' || ptr[col] == 'x')
          && ptr[col - 1] == '0'
-         && !utf_head_off(ptr, ptr + col - 1)
+         && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
          && ascii_isxdigit(ptr[col + 1]))
         || (do_bin
             && col > 0
             && (ptr[col] == 'B' || ptr[col] == 'b')
             && ptr[col - 1] == '0'
-            && !utf_head_off(ptr, ptr + col - 1)
+            && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
             && ascii_isbdigit(ptr[col + 1]))) {
       // Found hexadecimal or binary number, move to its start.
       col--;
-      col -= utf_head_off(ptr, ptr + col);
+      col -= utf_head_off((char *)ptr, (char *)ptr + col);
     } else {
       // Search forward and then backward to find the start of number.
       col = pos->col;
@@ -4597,7 +4596,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     }
 
     if (col > pos->col && ptr[col - 1] == '-'
-        && !utf_head_off(ptr, ptr + col - 1)
+        && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
         && !do_unsigned) {
       negative = true;
       was_positive = false;
@@ -4643,7 +4642,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     curwin->w_cursor.col = col;
   } else {
     if (col > 0 && ptr[col - 1] == '-'
-        && !utf_head_off(ptr, ptr + col - 1)
+        && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
         && !visual
         && !do_unsigned) {
       // negative number
@@ -5036,7 +5035,7 @@ static void finish_write_reg(int name, yankreg_T *reg, yankreg_T *old_y_previous
 /// store `str` in register `name`
 ///
 /// @see write_reg_contents_ex
-void write_reg_contents(int name, const char_u *str, ssize_t len, int must_append)
+void write_reg_contents(int name, const char *str, ssize_t len, int must_append)
 {
   write_reg_contents_ex(name, str, len, must_append, kMTUnknown, 0L);
 }
@@ -5045,9 +5044,9 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
                             colnr_T block_len)
 {
   if (name == '/' || name == '=') {
-    char_u *s = (char_u *)strings[0];
+    char *s = strings[0];
     if (strings[0] == NULL) {
-      s = (char_u *)"";
+      s = "";
     } else if (strings[1] != NULL) {
       emsg(_("E883: search pattern and expression register may not "
              "contain two or more lines"));
@@ -5067,7 +5066,7 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
     return;
   }
 
-  str_to_reg(reg, yank_type, (char *)strings, STRLEN((char_u *)strings),
+  str_to_reg(reg, yank_type, (char *)strings, STRLEN(strings),
              block_len, true);
   finish_write_reg(name, reg, old_y_previous);
 }
@@ -5090,7 +5089,7 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
 ///                    is an uppercase letter.
 /// @param yank_type The motion type (kMTUnknown to auto detect)
 /// @param block_len width of visual block
-void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_append,
+void write_reg_contents_ex(int name, const char *str, ssize_t len, bool must_append,
                            MotionType yank_type, colnr_T block_len)
 {
   if (len < 0) {
@@ -5099,7 +5098,7 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
 
   // Special case: '/' search pattern
   if (name == '/') {
-    set_last_search_pat(str, RE_SEARCH, true, true);
+    set_last_search_pat((char_u *)str, RE_SEARCH, true, true);
     return;
   }
 
@@ -5107,14 +5106,14 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
     buf_T *buf;
 
     if (ascii_isdigit(*str)) {
-      int num = atoi((char *)str);
+      int num = atoi(str);
 
       buf = buflist_findnr(num);
       if (buf == NULL) {
         semsg(_(e_nobufnr), (int64_t)num);
       }
     } else {
-      buf = buflist_findnr(buflist_findpat((char *)str, (char *)str + STRLEN(str),
+      buf = buflist_findnr(buflist_findpat(str, str + STRLEN(str),
                                            true, false, false));
     }
     if (buf == NULL) {
@@ -5155,7 +5154,7 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
   if (!(reg = init_write_reg(name, &old_y_previous, must_append))) {
     return;
   }
-  str_to_reg(reg, yank_type, (char *)str, (size_t)len, block_len, false);
+  str_to_reg(reg, yank_type, str, (size_t)len, block_len, false);
   finish_write_reg(name, reg, old_y_previous);
 }
 
@@ -5425,7 +5424,7 @@ void cursor_pos_info(dict_T *dict)
           len = (long)bd.textlen;
           break;
         case 'V':
-          s = ml_get(lnum);
+          s = (char_u *)ml_get(lnum);
           len = MAXCOL;
           break;
         case 'v': {
@@ -5434,7 +5433,7 @@ void cursor_pos_info(dict_T *dict)
           colnr_T end_col = (lnum == max_pos.lnum)
                             ? max_pos.col - start_col + 1 : MAXCOL;
 
-          s = ml_get(lnum) + start_col;
+          s = (char_u *)ml_get(lnum) + start_col;
           len = end_col;
         }
         break;
@@ -5455,14 +5454,14 @@ void cursor_pos_info(dict_T *dict)
           word_count_cursor += word_count;
           char_count_cursor += char_count;
           byte_count_cursor = byte_count
-                              + line_count_info(ml_get(lnum), &word_count_cursor,
+                              + line_count_info((char_u *)ml_get(lnum), &word_count_cursor,
                                                 &char_count_cursor,
                                                 (varnumber_T)curwin->w_cursor.col + 1,
                                                 eol_size);
         }
       }
       // Add to the running totals
-      byte_count += line_count_info(ml_get(lnum), &word_count, &char_count,
+      byte_count += line_count_info((char_u *)ml_get(lnum), &word_count, &char_count,
                                     (varnumber_T)MAXCOL, eol_size);
     }
 
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index c0d5616666..158c22efaf 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -821,10 +821,10 @@ int os_fchown(int fd, uv_uid_t owner, uv_gid_t group)
 /// Check if a path exists.
 ///
 /// @return `true` if `path` exists
-bool os_path_exists(const char_u *path)
+bool os_path_exists(const char *path)
 {
   uv_stat_t statbuf;
-  return os_stat((char *)path, &statbuf) == kLibuvSuccess;
+  return os_stat(path, &statbuf) == kLibuvSuccess;
 }
 
 /// Sets file access and modification times.
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 461a79c37b..35390e3dc1 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -503,7 +503,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
   // Move the file names to allocated memory.
   for (j = 0, i = 0; i < *num_file; i++) {
     // Require the files to exist. Helps when using /bin/sh
-    if (!(flags & EW_NOTFOUND) && !os_path_exists((char_u *)(*file)[i])) {
+    if (!(flags & EW_NOTFOUND) && !os_path_exists((*file)[i])) {
       continue;
     }
 
@@ -1112,7 +1112,7 @@ static void out_data_append_to_screen(char *output, size_t *count, bool eof)
         goto end;
       }
 
-      (void)msg_outtrans_len_attr((char_u *)p, i, 0);
+      (void)msg_outtrans_len_attr(p, i, 0);
       p += i;
     }
   }
@@ -1208,7 +1208,7 @@ static void read_input(DynamicBuffer *buf)
 {
   size_t written = 0, l = 0, len = 0;
   linenr_T lnum = curbuf->b_op_start.lnum;
-  char_u *lp = ml_get(lnum);
+  char_u *lp = (char_u *)ml_get(lnum);
 
   for (;;) {
     l = strlen((char *)lp + written);
@@ -1240,7 +1240,7 @@ static void read_input(DynamicBuffer *buf)
       if (lnum > curbuf->b_op_end.lnum) {
         break;
       }
-      lp = ml_get(lnum);
+      lp = (char_u *)ml_get(lnum);
       written = 0;
     } else if (len > 0) {
       written += len;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index a5cec6772f..5bbcbc7144 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -755,8 +755,9 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
             backslash_halve((char *)buf + len + 1);
           }
           // add existing file or symbolic link
-          if ((flags & EW_ALLLINKS) ? os_fileinfo_link((char *)buf, &file_info)
-                                    : os_path_exists(buf)) {
+          if ((flags & EW_ALLLINKS)
+              ? os_fileinfo_link((char *)buf, &file_info)
+              : os_path_exists((char *)buf)) {
             addfile(gap, buf, flags);
           }
         }
@@ -1461,7 +1462,7 @@ void addfile(garray_T *gap, char_u *f, int flags)
   if (!(flags & EW_NOTFOUND)
       && ((flags & EW_ALLLINKS)
           ? !os_fileinfo_link((char *)f, &file_info)
-          : !os_path_exists(f))) {
+          : !os_path_exists((char *)f))) {
     return;
   }
 
@@ -1926,7 +1927,7 @@ void path_fix_case(char *name)
   while ((entry = (char *)os_scandir_next(&dir))) {
     // Only accept names that differ in case and are the same byte
     // length. TODO: accept different length name.
-    if (STRICMP(tail, entry) == 0 && STRLEN(tail) == STRLEN(entry)) {
+    if (STRICMP(tail, entry) == 0 && strlen(tail) == strlen(entry)) {
       char_u newname[MAXPATHL + 1];
 
       // Verify the inode is equal.
@@ -1951,7 +1952,7 @@ void path_fix_case(char *name)
 int after_pathsep(const char *b, const char *p)
 {
   return p > b && vim_ispathsep(p[-1])
-         && utf_head_off((char_u *)b, (char_u *)p - 1) == 0;
+         && utf_head_off(b, p - 1) == 0;
 }
 
 /// Return true if file names "f1" and "f2" are in the same directory.
@@ -2272,7 +2273,7 @@ int path_full_dir_name(char *directory, char *buffer, size_t len)
   int SUCCESS = 0;
   int retval = OK;
 
-  if (STRLEN(directory) == 0) {
+  if (strlen(directory) == 0) {
     return os_dirname((char_u *)buffer, len);
   }
 
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index cc730ba307..3ba09b45a1 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -149,7 +149,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
   colnr_T col = 0;
   chartabsize_T cts;
 
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   while (*cts.cts_ptr != NUL && --column >= 0) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
     MB_PTR_ADV(cts.cts_ptr);
@@ -257,7 +257,7 @@ int linetabsize(char_u *s)
 int linetabsize_col(int startcol, char *s)
 {
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, curwin, 0, startcol, (char_u *)s, (char_u *)s);
+  init_chartabsize_arg(&cts, curwin, 0, startcol, s, s);
   while (*cts.cts_ptr != NUL) {
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
@@ -275,7 +275,7 @@ int linetabsize_col(int startcol, char *s)
 unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len)
 {
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   for (; *cts.cts_ptr != NUL && (len == MAXCOL || cts.cts_ptr < (char *)line + len);
        MB_PTR_ADV(cts.cts_ptr)) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
@@ -288,14 +288,14 @@ unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len
 ///
 /// "line" is the start of the line, "ptr" is the first relevant character.
 /// When "lnum" is zero do not use text properties that insert text.
-void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char_u *line,
-                          char_u *ptr)
+void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char *line,
+                          char *ptr)
 {
   cts->cts_win = wp;
   cts->cts_lnum = lnum;
   cts->cts_vcol = col;
-  cts->cts_line = (char *)line;
-  cts->cts_ptr = (char *)ptr;
+  cts->cts_line = line;
+  cts->cts_ptr = ptr;
   cts->cts_cur_text_width = 0;
   // TODO(bfredl): actually lookup inline virtual text here
   cts->cts_has_virt_text = false;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f9c4892b91..f1fc48ef40 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1250,7 +1250,7 @@ static int qf_parse_fmt_f(regmatch_T *rmp, int midx, qffields_T *fields, int pre
   // For separate filename patterns (%O, %P and %Q), the specified file
   // should exist.
   if (vim_strchr("OPQ", prefix) != NULL
-      && !os_path_exists((char_u *)fields->namebuf)) {
+      && !os_path_exists(fields->namebuf)) {
     return QF_FAIL;
   }
 
@@ -1564,7 +1564,7 @@ static int qf_parse_dir_pfx(int idx, qffields_T *fields, qf_list_T *qfl)
 static int qf_parse_file_pfx(int idx, qffields_T *fields, qf_list_T *qfl, char *tail)
 {
   fields->valid = false;
-  if (*fields->namebuf == NUL || os_path_exists((char_u *)fields->namebuf)) {
+  if (*fields->namebuf == NUL || os_path_exists(fields->namebuf)) {
     if (*fields->namebuf && idx == 'P') {
       qfl->qf_currfile = qf_push_dir(fields->namebuf, &qfl->qf_file_stack, true);
     } else if (idx == 'Q') {
@@ -2069,7 +2069,7 @@ static int qf_get_fnum(qf_list_T *qfl, char *directory, char *fname)
     // This should normally be true, but if make works without
     // "leaving directory"-messages we might have missed a
     // directory change.
-    if (!os_path_exists((char_u *)ptr)) {
+    if (!os_path_exists(ptr)) {
       xfree(ptr);
       directory = qf_guess_filepath(qfl, fname);
       if (directory) {
@@ -2223,7 +2223,7 @@ static char *qf_guess_filepath(qf_list_T *qfl, char *filename)
     xfree(fullname);
     fullname = concat_fnames(ds_ptr->dirname, filename, true);
 
-    if (os_path_exists((char_u *)fullname)) {
+    if (os_path_exists(fullname)) {
       break;
     }
 
@@ -3089,7 +3089,7 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   qf_fmt_text((fname != NULL || qfp->qf_lnum != 0)
               ? skipwhite(qfp->qf_text) : qfp->qf_text,
               (char *)tbuf, (int)tbuflen);
-  msg_prt_line(tbuf, false);
+  msg_prt_line((char *)tbuf, false);
 
   if (tbuf != IObuff) {
     xfree(tbuf);
@@ -5075,7 +5075,7 @@ static void vgr_init_regmatch(regmmatch_T *regmatch, char *s)
 static void vgr_display_fname(char *fname)
 {
   msg_start();
-  char *p = (char *)msg_strtrunc((char_u *)fname, true);
+  char *p = msg_strtrunc(fname, true);
   if (p == NULL) {
     msg_outtrans(fname);
   } else {
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index a52343e28b..f471f1c8e0 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1093,7 +1093,7 @@ void unref_extmatch(reg_extmatch_T *em)
 static int reg_prev_class(void)
 {
   if (rex.input > rex.line) {
-    return mb_get_class_tab(rex.input - 1 - utf_head_off(rex.line, rex.input - 1),
+    return mb_get_class_tab(rex.input - 1 - utf_head_off((char *)rex.line, (char *)rex.input - 1),
                             rex.reg_buf->b_chartab);
   }
   return -1;
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index 88f0d781af..b951df69d6 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -4765,8 +4765,8 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
                 reg_getline(rp->rs_un.regsave.rs_u.pos.lnum);
 
               rp->rs_un.regsave.rs_u.pos.col -=
-                utf_head_off(line,
-                             line + rp->rs_un.regsave.rs_u.pos.col - 1)
+                utf_head_off((char *)line,
+                             (char *)line + rp->rs_un.regsave.rs_u.pos.col - 1)
                 + 1;
             }
           } else {
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index d4db710d93..e1327ce155 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -5595,7 +5595,7 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
       }
       if ((int)(rex.input - rex.line) >= state->val) {
         rex.input -= state->val;
-        rex.input -= utf_head_off(rex.line, rex.input);
+        rex.input -= utf_head_off((char *)rex.line, (char *)rex.input);
       } else {
         rex.input = rex.line;
       }
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index e85167f8fd..a38f743081 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -1822,7 +1822,7 @@ static void cmd_source_buffer(const exarg_T *const eap)
     if (ga.ga_len > 400) {
       ga_set_growsize(&ga, MIN(ga.ga_len, 8000));
     }
-    ga_concat(&ga, (char *)ml_get(curr_lnum));
+    ga_concat(&ga, ml_get(curr_lnum));
     ga_append(&ga, NL);
   }
   ((char *)ga.ga_data)[ga.ga_len - 1] = NUL;
diff --git a/src/nvim/search.c b/src/nvim/search.c
index e995081df8..d7f8d4e1cd 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -853,7 +853,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
               pos->col--;
               if (pos->lnum <= buf->b_ml.ml_line_count) {
                 ptr = ml_get_buf(buf, pos->lnum, false);
-                pos->col -= utf_head_off(ptr, ptr + pos->col);
+                pos->col -= utf_head_off((char *)ptr, (char *)ptr + pos->col);
               }
             }
             if (end_pos != NULL) {
@@ -1250,7 +1250,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
           memmove(msgbuf + STRLEN(p) + 1, off_buf, off_len);
         }
 
-        trunc = msg_strtrunc(msgbuf, true);
+        trunc = (char_u *)msg_strtrunc((char *)msgbuf, true);
         if (trunc != NULL) {
           xfree(msgbuf);
           msgbuf = trunc;
@@ -1589,7 +1589,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
         if (col == 0) {
           return FAIL;
         }
-        col -= utf_head_off(p, p + col - 1) + 1;
+        col -= utf_head_off((char *)p, (char *)p + col - 1) + 1;
       }
       if (lastc_bytelen == 1) {
         if (p[col] == c && stop) {
@@ -1610,7 +1610,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
       col += lastc_bytelen - 1;
     } else {
       // To previous char, which may be multi-byte.
-      col -= utf_head_off(p, p + col);
+      col -= utf_head_off((char *)p, (char *)p + col);
     }
   }
   curwin->w_cursor.col = col;
@@ -1641,7 +1641,7 @@ static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol)
 {
   col--;
   if (col > 0) {
-    col -= utf_head_off(linep, linep + col);
+    col -= utf_head_off((char *)linep, (char *)linep + col);
   }
   if (prevcol) {
     *prevcol = col;
@@ -1664,7 +1664,7 @@ static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos)
   char_u *delim_copy = vim_strnsave(linep + startpos->col + 1, delim_len);
   bool found = false;
   for (lnum = startpos->lnum; lnum <= endpos->lnum; lnum++) {
-    char_u *line = ml_get(lnum);
+    char_u *line = (char_u *)ml_get(lnum);
 
     for (p = line + (lnum == startpos->lnum ? startpos->col + 1 : 0); *p; p++) {
       if (lnum == endpos->lnum && (colnr_T)(p - line) >= endpos->col) {
@@ -1768,7 +1768,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 
   pos = curwin->w_cursor;
   pos.coladd = 0;
-  char_u *linep = ml_get(pos.lnum);     // pointer to current line
+  char_u *linep = (char_u *)ml_get(pos.lnum);     // pointer to current line
 
   // vi compatible matching
   bool cpo_match = (vim_strchr(p_cpo, CPO_MATCH) != NULL);
@@ -1923,7 +1923,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
         pos.lnum += hash_dir;
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         line_breakcheck();              // check for CTRL-C typed
         ptr = (char_u *)skipwhite((char *)linep);
         if (*ptr != '#') {
@@ -2003,7 +2003,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
 
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         pos.col = (colnr_T)STRLEN(linep);         // pos.col on trailing NUL
         do_quotes = -1;
         line_breakcheck();
@@ -2018,7 +2018,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
         }
       } else {
         pos.col--;
-        pos.col -= utf_head_off(linep, linep + pos.col);
+        pos.col -= utf_head_off((char *)linep, (char *)linep + pos.col);
       }
     } else {                          // forward search
       if (linep[pos.col] == NUL
@@ -2038,7 +2038,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
 
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         pos.col = 0;
         do_quotes = -1;
         line_breakcheck();
@@ -2088,7 +2088,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
               match_pos = pos;
               match_pos.col--;
             }
-            linep = ml_get(pos.lnum);  // may have been released
+            linep = (char_u *)ml_get(pos.lnum);  // may have been released
           }
         } else if (linep[pos.col - 1] == '/'
                    && linep[pos.col] == '*'
@@ -2158,7 +2158,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           }
         }
         if (pos.lnum > 1) {
-          ptr = ml_get(pos.lnum - 1);
+          ptr = (char_u *)ml_get(pos.lnum - 1);
           if (*ptr && *(ptr + STRLEN(ptr) - 1) == '\\') {
             do_quotes = 1;
             if (start_in_quotes == kNone) {
@@ -2172,7 +2172,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           }
 
           // ml_get() only keeps one line, need to get linep again
-          linep = ml_get(pos.lnum);
+          linep = (char_u *)ml_get(pos.lnum);
         }
       }
     }
@@ -2648,7 +2648,7 @@ int linewhite(linenr_T lnum)
 {
   char_u *p;
 
-  p = (char_u *)skipwhite((char *)ml_get(lnum));
+  p = (char_u *)skipwhite(ml_get(lnum));
   return *p == NUL;
 }
 
@@ -3488,7 +3488,7 @@ void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// mark.
 static char_u *get_line_and_copy(linenr_T lnum, char_u *buf)
 {
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   STRLCPY(buf, line, LSIZE);
   return buf;
 }
@@ -3625,7 +3625,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
               msg_putchar('\n');  // cursor below last one */
               if (!got_int) {  // don't display if 'q' typed at "--more--"
                                // message
-                msg_home_replace_hl(new_fname);
+                msg_home_replace_hl((char *)new_fname);
                 msg_puts(_(" (includes previously listed match)"));
                 prev_fname = NULL;
               }
@@ -3655,7 +3655,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
           for (i = 0; i < depth_displayed; i++) {
             msg_puts("  ");
           }
-          msg_home_replace(files[depth_displayed].name);
+          msg_home_replace((char *)files[depth_displayed].name);
           msg_puts(" -->\n");
         }
         if (!got_int) {                     // don't display if 'q' typed
@@ -3937,7 +3937,7 @@ search_line:
           }
           if (!got_int) {             // don't display if 'q' typed
                                       // at "--more--" message
-            msg_home_replace_hl(curr_fname);
+            msg_home_replace_hl((char *)curr_fname);
           }
           prev_fname = curr_fname;
         }
@@ -4146,7 +4146,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       msg_puts_attr((const char *)IObuff, HL_ATTR(HLF_N));
       msg_puts(" ");
     }
-    msg_prt_line(line, false);
+    msg_prt_line((char *)line, false);
     ui_flush();                        // show one line at a time
 
     // Definition continues until line that doesn't end with '\'
@@ -4163,7 +4163,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       if (++*lnum > curbuf->b_ml.ml_line_count) {
         break;
       }
-      line = ml_get(*lnum);
+      line = (char_u *)ml_get(*lnum);
     }
     msg_putchar('\n');
   }
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 1259736e0e..d8bc4b22c2 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -571,7 +571,7 @@ static void find_word(matchinf_T *mip, int mode)
     arridx = endidx[endidxcnt];
     wlen = endlen[endidxcnt];
 
-    if (utf_head_off(ptr, ptr + wlen) > 0) {
+    if (utf_head_off((char *)ptr, (char *)ptr + wlen) > 0) {
       continue;             // not at first byte of character
     }
     if (spell_iswordp(ptr + wlen, mip->mi_win)) {
@@ -2479,7 +2479,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
     if (lnum == 1) {
       need_cap = true;
     } else {
-      line = ml_get(lnum - 1);
+      line = (char_u *)ml_get(lnum - 1);
       if (*skipwhite((char *)line) == NUL) {
         need_cap = true;
       } else {
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 0f8034312e..c472cac27d 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -3197,7 +3197,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
                      _("line %6d, word %6ld - %s"),
                      lnum, spin->si_foldwcount + spin->si_keepwcount, w);
         msg_start();
-        msg_outtrans_long_attr(message, 0);
+        msg_outtrans_long_attr((char *)message, 0);
         msg_clr_eos();
         msg_didout = false;
         msg_col = 0;
@@ -5339,7 +5339,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
   } else {
     // Check for overwriting before doing things that may take a lot of
     // time.
-    if (!over_write && os_path_exists((char_u *)wfname)) {
+    if (!over_write && os_path_exists(wfname)) {
       emsg(_(e_exists));
       goto theend;
     }
@@ -5389,7 +5389,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       spin.si_region = 1 << i;
 
       vim_snprintf((char *)fname, MAXPATHL, "%s.aff", innames[i]);
-      if (os_path_exists(fname)) {
+      if (os_path_exists((char *)fname)) {
         // Read the .aff file.  Will init "spin->si_conv" based on the
         // "SET" line.
         afile[i] = spell_read_aff(&spin, fname);
@@ -5500,7 +5500,7 @@ static void spell_message(const spellinfo_T *spin, char *str)
 // ":[count]spellrare  {word}"
 void ex_spell(exarg_T *eap)
 {
-  spell_add_word((char_u *)eap->arg, (int)STRLEN(eap->arg),
+  spell_add_word((char_u *)eap->arg, (int)strlen(eap->arg),
                  eap->cmdidx == CMD_spellwrong ? SPELL_ADD_BAD :
                  eap->cmdidx == CMD_spellrare ? SPELL_ADD_RARE : SPELL_ADD_GOOD,
                  eap->forceit ? 0 : (int)eap->line2,
@@ -5810,7 +5810,7 @@ static int write_spell_prefcond(FILE *fd, garray_T *gap, size_t *fwv)
     // <prefcond> : <condlen> <condstr>
     char *p = ((char **)gap->ga_data)[i];
     if (p != NULL) {
-      size_t len = STRLEN(p);
+      size_t len = strlen(p);
       if (fd != NULL) {
         assert(len <= INT_MAX);
         fputc((int)len, fd);
@@ -5873,7 +5873,7 @@ static void set_map_str(slang_T *lp, char_u *map)
         utf_char2bytes(headc, b + cl + 1);
         b[cl + 1 + headcl] = NUL;
         hash = hash_hash((char_u *)b);
-        hi = hash_lookup(&lp->sl_map_hash, (const char *)b, STRLEN(b), hash);
+        hi = hash_lookup(&lp->sl_map_hash, (const char *)b, strlen(b), hash);
         if (HASHITEM_EMPTY(hi)) {
           hash_add_item(&lp->sl_map_hash, hi, (char_u *)b, hash);
         } else {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index f055cc9b0e..1319894226 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -610,7 +610,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
      * Skip lines that end in a backslash.
      */
     for (; start_lnum > 1; start_lnum--) {
-      line = ml_get(start_lnum - 1);
+      line = (char_u *)ml_get(start_lnum - 1);
       if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
         break;
       }
@@ -1711,7 +1711,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         const char_u *cur_pos = line + current_col;
         if (vim_iswordp_buf(cur_pos, syn_buf)
             && (current_col == 0
-                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off(line, cur_pos - 1),
+                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off((char *)line, (char *)cur_pos - 1),
                                     syn_buf))) {
           syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
                                     &next_list, cur_si, &cchar);
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 5270412382..4fd99b058b 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -742,7 +742,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
                        (int)(tagp.tagkind_end - tagp.tagkind));
     }
     msg_advance(13);
-    msg_outtrans_len_attr(tagp.tagname,
+    msg_outtrans_len_attr((char *)tagp.tagname,
                           (int)(tagp.tagname_end - tagp.tagname),
                           HL_ATTR(HLF_T));
     msg_putchar(' ');
@@ -1230,7 +1230,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
         continue;
       }
 
-      len += STRLEN(tv->vval.v_string) + 1;   // Space for "\tVALUE"
+      len += strlen(tv->vval.v_string) + 1;   // Space for "\tVALUE"
       if (!STRCMP(dict_key, "name")) {
         res_name = (char_u *)tv->vval.v_string;
         continue;
@@ -1497,7 +1497,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
     curbuf->b_help = false;
   }
 
-  orgpat.len = (int)STRLEN(pat);
+  orgpat.len = (int)strlen(pat);
   if (curbuf->b_help) {
     // When "@ab" is specified use only the "ab" language, otherwise
     // search all languages.
@@ -1550,7 +1550,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
   if ((flags & TAG_KEEP_LANG)
       && help_lang_find == NULL
       && curbuf->b_fname != NULL
-      && (i = (int)STRLEN(curbuf->b_fname)) > 4
+      && (i = (int)strlen(curbuf->b_fname)) > 4
       && STRICMP(curbuf->b_fname + i - 4, ".txt") == 0) {
     is_txt = true;
   }
@@ -1595,7 +1595,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
           if ((flags & TAG_KEEP_LANG)
               && help_lang_find == NULL
               && curbuf->b_fname != NULL
-              && (i = (int)STRLEN(curbuf->b_fname)) > 4
+              && (i = (int)strlen(curbuf->b_fname)) > 4
               && curbuf->b_fname[i - 1] == 'x'
               && curbuf->b_fname[i - 4] == '.'
               && STRNICMP(curbuf->b_fname + i - 3, help_lang, 2) == 0) {
@@ -2174,7 +2174,7 @@ parse_line:
               hash = hash_hash((char_u *)mfp);
             }
             hi = hash_lookup(&ht_match[mtt], (const char *)mfp,
-                             STRLEN(mfp), hash);
+                             strlen(mfp), hash);
             if (HASHITEM_EMPTY(hi)) {
               hash_add_item(&ht_match[mtt], hi, (char_u *)mfp, hash);
               ga_grow(&ga_match[mtt], 1);
@@ -2713,7 +2713,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
    * file.  Also accept a file name for which there is a matching BufReadCmd
    * autocommand event (e.g., http://sys/file).
    */
-  if (!os_path_exists(fname)
+  if (!os_path_exists((char *)fname)
       && !has_autocmd(EVENT_BUFREADCMD, (char *)fname,
                       NULL)) {
     retval = NOTAGFILE;
@@ -3168,7 +3168,7 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
   char_u *buf = xmalloc(MAXPATHL);
   if (start != NULL) {
     if (end == NULL) {
-      end = start + STRLEN(start);
+      end = start + strlen(start);
       while (end > start && (end[-1] == '\r' || end[-1] == '\n')) {
         end--;
       }
@@ -3180,7 +3180,7 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
     STRLCPY(buf, start, len + 1);
   }
   buf[len] = NUL;
-  retval = tv_dict_add_str(dict, field_name, STRLEN(field_name),
+  retval = tv_dict_add_str(dict, field_name, strlen(field_name),
                            (const char *)buf);
   xfree(buf);
   return retval;
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 125146f712..5ded0c9ab2 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -470,7 +470,7 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags,
   char_u *flags = NULL;        // init for GCC
   char_u *ptr;
 
-  ptr = ml_get(lnum);
+  ptr = (char_u *)ml_get(lnum);
   if (do_comments) {
     *leader_len = get_leader_len((char *)ptr, (char **)leader_flags, false, true);
   } else {
@@ -493,7 +493,7 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags,
 /// @return  true if line "lnum" ends in a white character.
 static bool ends_in_white(linenr_T lnum)
 {
-  char_u *s = ml_get(lnum);
+  char_u *s = (char_u *)ml_get(lnum);
   size_t l;
 
   if (*s == NUL) {
@@ -552,9 +552,9 @@ static bool same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, i
 
   // Get current line and next line, compare the leaders.
   // The first line has to be saved, only one line can be locked at a time.
-  line1 = vim_strsave(ml_get(lnum));
+  line1 = vim_strsave((char_u *)ml_get(lnum));
   for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
-  line2 = ml_get(lnum + 1);
+  line2 = (char_u *)ml_get(lnum + 1);
   for (idx2 = 0; idx2 < leader2_len; idx2++) {
     if (!ascii_iswhite(line2[idx2])) {
       if (line1[idx1++] != line2[idx2]) {
@@ -586,7 +586,7 @@ static bool paragraph_start(linenr_T lnum)
   if (lnum <= 1) {
     return true;                // start of the file
   }
-  p = ml_get(lnum - 1);
+  p = (char_u *)ml_get(lnum - 1);
   if (*p == NUL) {
     return true;                // after empty line
   }
diff --git a/src/nvim/textobject.c b/src/nvim/textobject.c
index 02174edeb1..a8f4cc7aeb 100644
--- a/src/nvim/textobject.c
+++ b/src/nvim/textobject.c
@@ -213,13 +213,13 @@ bool findpar(bool *pincl, int dir, long count, int what, bool both)
   }
   curwin->w_cursor.lnum = curr;
   if (curr == curbuf->b_ml.ml_line_count && what != '}') {
-    char_u *line = ml_get(curr);
+    char_u *line = (char_u *)ml_get(curr);
 
     // Put the cursor on the last character in the last line and make the
     // motion inclusive.
     if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0) {
       curwin->w_cursor.col--;
-      curwin->w_cursor.col -= utf_head_off(line, line + curwin->w_cursor.col);
+      curwin->w_cursor.col -= utf_head_off((char *)line, (char *)line + curwin->w_cursor.col);
       *pincl = true;
     }
   } else {
@@ -260,7 +260,7 @@ bool startPS(linenr_T lnum, int para, bool both)
 {
   char_u *s;
 
-  s = ml_get(lnum);
+  s = (char_u *)ml_get(lnum);
   if (*s == para || *s == '\f' || (both && *s == '}')) {
     return true;
   }
@@ -1467,7 +1467,7 @@ static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *e
 
   while (col_start > 0) {
     col_start--;
-    col_start -= utf_head_off(line, line + col_start);
+    col_start -= utf_head_off((char *)line, (char *)line + col_start);
     n = 0;
     if (escape != NULL) {
       while (col_start - n > 0 && vim_strchr((char *)escape,
diff --git a/src/nvim/tui/terminfo.c b/src/nvim/tui/terminfo.c
index ce48059b94..229e340dc3 100644
--- a/src/nvim/tui/terminfo.c
+++ b/src/nvim/tui/terminfo.c
@@ -189,7 +189,7 @@ void terminfo_info_msg(const unibi_term *const ut)
       msg_printf_attr(0, "  %-25s %-10s = ", unibi_name_str(i),
                       unibi_short_name_str(i));
       // Most of these strings will contain escape sequences.
-      msg_outtrans_special((char_u *)s, false, 0);
+      msg_outtrans_special(s, false, 0);
       msg_putchar('\n');
     }
   }
@@ -216,7 +216,7 @@ void terminfo_info_msg(const unibi_term *const ut)
     msg_puts("Extended string capabilities:\n");
     for (size_t i = 0; i < unibi_count_ext_str(ut); i++) {
       msg_printf_attr(0, "  %-25s = ", unibi_get_ext_str_name(ut, i));
-      msg_outtrans_special((char_u *)unibi_get_ext_str(ut, i), false, 0);
+      msg_outtrans_special(unibi_get_ext_str(ut, i), false, 0);
       msg_putchar('\n');
     }
   }
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 97a925f3ad..5f086df4e9 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -651,7 +651,7 @@ char *u_get_undo_file_name(const char *const buf_ffname, const bool reading)
   char fname_buf[MAXPATHL];
   // Expand symlink in the file name, so that we put the undo file with the
   // actual file instead of with the symlink.
-  if (resolve_symlink((const char_u *)ffname, (char_u *)fname_buf) == OK) {
+  if (resolve_symlink(ffname, fname_buf) == OK) {
     ffname = fname_buf;
   }
 #endif
@@ -713,7 +713,7 @@ char *u_get_undo_file_name(const char *const buf_ffname, const bool reading)
 
     // When reading check if the file exists.
     if (undo_file_name != NULL
-        && (!reading || os_path_exists((char_u *)undo_file_name))) {
+        && (!reading || os_path_exists(undo_file_name))) {
       break;
     }
     XFREE_CLEAR(undo_file_name);
@@ -1177,7 +1177,7 @@ void u_write_undo(const char *const name, const bool forceit, buf_T *const buf,
 
   // If the undo file already exists, verify that it actually is an undo
   // file, and delete it.
-  if (os_path_exists((char_u *)file_name)) {
+  if (os_path_exists(file_name)) {
     if (name == NULL || !forceit) {
       // Check we can read it and it's an undo file.
       fd = os_open(file_name, O_RDONLY, 0);
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 5b2101587f..9cc9fb5588 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -531,7 +531,7 @@ static void uc_list(char *name, size_t name_len)
         }
       }
 
-      msg_outtrans_special((char_u *)cmd->uc_rep, false,
+      msg_outtrans_special(cmd->uc_rep, false,
                            name_len == 0 ? Columns - 47 : 0);
       if (p_verbose > 0) {
         last_set_msg(cmd->uc_script_ctx);
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 74ea1172ee..c11484d1b8 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6578,7 +6578,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
    * Go one char back to ":" before "//" even when ':' is not in 'isfname'.
    */
   while ((char_u *)ptr > line) {
-    if ((len = (size_t)(utf_head_off(line, (char_u *)ptr - 1))) > 0) {
+    if ((len = (size_t)(utf_head_off((char *)line, ptr - 1))) > 0) {
       ptr -= len + 1;
     } else if (vim_isfilec(ptr[-1]) || ((options & FNAME_HYP) && path_is_url(ptr - 1))) {
       ptr--;