refactor: replace char_u with char 24 (#21823)

refactor: replace char_u with char

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

60 files changed, 503 insertions, 505 deletions

diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index 44e7ed3986..ab3b3485e4 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -698,7 +698,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
   }
 
   if (opts->sign_text.type == kObjectTypeString) {
-    if (!init_sign_text((char **)&decor.sign_text,
+    if (!init_sign_text(&decor.sign_text,
                         opts->sign_text.data.string.data)) {
       api_set_error(err, kErrorTypeValidation, "sign_text is not a valid value");
       goto error;
diff --git a/src/nvim/api/private/converter.c b/src/nvim/api/private/converter.c
index 7770ba39d8..58ff552ab7 100644
--- a/src/nvim/api/private/converter.c
+++ b/src/nvim/api/private/converter.c
@@ -358,7 +358,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
   }
 
   case kObjectTypeLuaRef: {
-    char *name = (char *)register_luafunc(api_new_luaref(obj.data.luaref));
+    char *name = register_luafunc(api_new_luaref(obj.data.luaref));
     tv->v_type = VAR_FUNC;
     tv->vval.v_string = xstrdup(name);
     break;
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index fa9aa27774..5aec9ccf9d 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -540,9 +540,9 @@ static char_u transchar_charbuf[11];
 /// @param[in]  c  Character to translate.
 ///
 /// @return translated character into a static buffer.
-char_u *transchar(int c)
+char *transchar(int c)
 {
-  return transchar_buf(curbuf, c);
+  return (char *)transchar_buf(curbuf, c);
 }
 
 char_u *transchar_buf(const buf_T *buf, int c)
@@ -584,7 +584,7 @@ char_u *transchar_byte(const int c)
     transchar_nonprint(curbuf, transchar_charbuf, c);
     return transchar_charbuf;
   }
-  return transchar(c);
+  return (char_u *)transchar(c);
 }
 
 /// Convert non-printable characters to 2..4 printable ones
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index c876e04f29..c1059c40f0 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -979,7 +979,7 @@ static void showmatches_oneline(expand_T *xp, char **matches, int numMatches, in
         // Expansion was done before and special characters
         // were escaped, need to halve backslashes.  Also
         // $HOME has been replaced with ~/.
-        char *exp_path = (char *)expand_env_save_opt(matches[j], true);
+        char *exp_path = expand_env_save_opt(matches[j], true);
         char *path = exp_path != NULL ? exp_path : matches[j];
         char *halved_slash = backslash_halve_save(path);
         isdir = os_isdir(halved_slash);
@@ -2914,14 +2914,14 @@ static void expand_shellcmd_onedir(char *buf, char *s, size_t l, char *pat, char
 
     if (strlen(name) > l) {
       // Check if this name was already found.
-      hash_T hash = hash_hash((char_u *)name + l);
+      hash_T hash = hash_hash(name + l);
       hashitem_T *hi =
         hash_lookup(ht, (const char *)(name + l), strlen(name + l), hash);
       if (HASHITEM_EMPTY(hi)) {
         // Remove the path that was prepended.
         STRMOVE(name, name + l);
         ((char **)gap->ga_data)[gap->ga_len++] = name;
-        hash_add_item(ht, hi, (char_u *)name, hash);
+        hash_add_item(ht, hi, name, hash);
         name = NULL;
       }
     }
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index 3dfbcd1f81..ad615969ba 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -802,7 +802,7 @@ static linenr_T debuggy_find(bool file, char *fname, linenr_T after, garray_T *g
       // while matching should abort it.
       prev_got_int = got_int;
       got_int = false;
-      if (vim_regexec_prog(&bp->dbg_prog, false, (char_u *)name, (colnr_T)0)) {
+      if (vim_regexec_prog(&bp->dbg_prog, false, name, (colnr_T)0)) {
         lnum = bp->dbg_lnum;
         if (fp != NULL) {
           *fp = bp->dbg_forceit;
diff --git a/src/nvim/decoration.c b/src/nvim/decoration.c
index 037eb9f0d9..9274138cb6 100644
--- a/src/nvim/decoration.c
+++ b/src/nvim/decoration.c
@@ -407,7 +407,7 @@ void decor_redraw_signs(buf_T *buf, int row, int *num_signs, SignTextAttrs sattr
       }
       if (j < SIGN_SHOW_MAX) {
         sattrs[j] = (SignTextAttrs) {
-          .text = (char *)decor->sign_text,
+          .text = decor->sign_text,
           .hl_attr_id = decor->sign_hl_id == 0 ? 0 : syn_id2attr(decor->sign_hl_id),
           .priority = decor->priority
         };
diff --git a/src/nvim/decoration.h b/src/nvim/decoration.h
index cee1eb2f94..c9ec8ede7f 100644
--- a/src/nvim/decoration.h
+++ b/src/nvim/decoration.h
@@ -58,7 +58,7 @@ struct Decoration {
   DecorPriority priority;
   int col;  // fixed col value, like win_col
   int virt_text_width;  // width of virt_text
-  char_u *sign_text;
+  char *sign_text;
   int sign_hl_id;
   int number_hl_id;
   int line_hl_id;
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 40be6b1abc..7fbde4f45b 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2293,7 +2293,7 @@ static bool diff_equal_char(const char *const p1, const char *const p2, int *con
 static int diff_cmp(char *s1, char *s2)
 {
   if ((diff_flags & DIFF_IBLANK)
-      && (*(char_u *)skipwhite(s1) == NUL || *skipwhite(s2) == NUL)) {
+      && (*skipwhite(s1) == NUL || *skipwhite(s2) == NUL)) {
     return 0;
   }
 
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 144817fe2b..a057978a5e 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1489,7 +1489,7 @@ int do_digraph(int c)
 
 /// Find a digraph for "val".  If found return the string to display it.
 /// If not found return NULL.
-char_u *get_digraph_for_char(int val_arg)
+char *get_digraph_for_char(int val_arg)
 {
   const int val = val_arg;
   const digr_T *dp;
@@ -1506,7 +1506,7 @@ char_u *get_digraph_for_char(int val_arg)
         r[0] = dp->char1;
         r[1] = dp->char2;
         r[2] = NUL;
-        return r;
+        return (char *)r;
       }
       dp++;
     }
@@ -1749,16 +1749,16 @@ static void digraph_getlist_appendpair(const digr_T *dp, list_T *l)
   list_T *l2 = tv_list_alloc(2);
   tv_list_append_list(l, l2);
 
-  char_u buf[30];
-  buf[0] = dp->char1;
-  buf[1] = dp->char2;
+  char buf[30];
+  buf[0] = (char)dp->char1;
+  buf[1] = (char)dp->char2;
   buf[2] = NUL;
-  tv_list_append_string(l2, (char *)buf, -1);
+  tv_list_append_string(l2, buf, -1);
 
-  char_u *p = buf;
-  p += utf_char2bytes(dp->result, (char *)p);
+  char *p = buf;
+  p += utf_char2bytes(dp->result, p);
   *p = NUL;
-  tv_list_append_string(l2, (char *)buf, -1);
+  tv_list_append_string(l2, buf, -1);
 }
 
 void digraph_getlist_common(bool list_all, typval_T *rettv)
@@ -1824,7 +1824,7 @@ struct dg_header_entry {
 static void printdigraph(const digr_T *dp, result_T *previous)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  char_u buf[30];
+  char buf[30];
   int list_width = 13;
 
   if (dp->result == 0) {
@@ -1854,29 +1854,29 @@ static void printdigraph(const digr_T *dp, result_T *previous)
     }
   }
 
-  char_u *p = &buf[0];
-  *p++ = dp->char1;
-  *p++ = dp->char2;
+  char *p = &buf[0];
+  *p++ = (char)dp->char1;
+  *p++ = (char)dp->char2;
   *p++ = ' ';
   *p = NUL;
-  msg_outtrans((char *)buf);
+  msg_outtrans(buf);
   p = buf;
 
   // add a space to draw a composing char on
   if (utf_iscomposing(dp->result)) {
     *p++ = ' ';
   }
-  p += utf_char2bytes(dp->result, (char *)p);
+  p += utf_char2bytes(dp->result, p);
 
   *p = NUL;
-  msg_outtrans_attr((char *)buf, HL_ATTR(HLF_8));
+  msg_outtrans_attr(buf, HL_ATTR(HLF_8));
   p = buf;
   if (char2cells(dp->result) == 1) {
     *p++ = ' ';
   }
   assert(p >= buf);
-  vim_snprintf((char *)p, sizeof(buf) - (size_t)(p - buf), " %3d", dp->result);
-  msg_outtrans((char *)buf);
+  vim_snprintf(p, sizeof(buf) - (size_t)(p - buf), " %3d", dp->result);
+  msg_outtrans(buf);
 }
 
 /// Get the two digraph characters from a typval.
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index e9890e8751..e7efb14559 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -1432,7 +1432,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           }
           char_attr = win_hl_attr(wp, HLF_DED);
         }
-        char *const sbr = (char *)get_showbreak_value(wp);
+        char *const sbr = get_showbreak_value(wp);
         if (*sbr != NUL && need_showbreak) {
           // Draw 'showbreak' at the start of each broken line.
           p_extra = sbr;
@@ -1979,7 +1979,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           // We have just drawn the showbreak value, no need to add
           // space for it again.
           if (vcol == vcol_sbr) {
-            n_extra -= mb_charlen((char *)get_showbreak_value(wp));
+            n_extra -= mb_charlen(get_showbreak_value(wp));
             if (n_extra < 0) {
               n_extra = 0;
             }
@@ -2075,7 +2075,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         if (c == TAB && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
           int tab_len = 0;
           long vcol_adjusted = vcol;  // removed showbreak length
-          char *const sbr = (char *)get_showbreak_value(wp);
+          char *const sbr = get_showbreak_value(wp);
 
           // Only adjust the tab_len, when at the first column after the
           // showbreak value was drawn.
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 9f1a64fef5..f58fb3f371 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -3828,7 +3828,7 @@ static int get_string_tv(char **arg, typval_T *rettv, int evaluate)
         if (p[1] != '*') {
           flags |= FSK_SIMPLIFY;
         }
-        extra = trans_special((const char **)&p, strlen(p), (char_u *)name, flags, false, NULL);
+        extra = trans_special((const char **)&p, strlen(p), name, flags, false, NULL);
         if (extra != 0) {
           name += extra;
           if (name >= rettv->vval.v_string + len) {
@@ -3924,7 +3924,7 @@ static void partial_free(partial_T *pt)
   xfree(pt->pt_argv);
   tv_dict_unref(pt->pt_dict);
   if (pt->pt_name != NULL) {
-    func_unref((char_u *)pt->pt_name);
+    func_unref(pt->pt_name);
     xfree(pt->pt_name);
   } else {
     func_ptr_unref(pt->pt_func);
@@ -4490,7 +4490,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack
 
     // A partial does not have a copyID, because it cannot contain itself.
     if (pt != NULL) {
-      abort = set_ref_in_func((char_u *)pt->pt_name, pt->pt_func, copyID);
+      abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
       if (pt->pt_dict != NULL) {
         typval_T dtv;
 
@@ -4507,7 +4507,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack
     break;
   }
   case VAR_FUNC:
-    abort = set_ref_in_func((char_u *)tv->vval.v_string, NULL, copyID);
+    abort = set_ref_in_func(tv->vval.v_string, NULL, copyID);
     break;
   case VAR_UNKNOWN:
   case VAR_BOOL:
@@ -5104,7 +5104,7 @@ void common_function(typval_T *argvars, typval_T *rettv, bool is_funcref)
         xfree(name);
       } else {
         pt->pt_name = name;
-        func_ref((char_u *)name);
+        func_ref(name);
       }
 
       rettv->v_type = VAR_PARTIAL;
@@ -5113,7 +5113,7 @@ void common_function(typval_T *argvars, typval_T *rettv, bool is_funcref)
       // result is a VAR_FUNC
       rettv->v_type = VAR_FUNC;
       rettv->vval.v_string = name;
-      func_ref((char_u *)name);
+      func_ref(name);
     }
   }
 theend:
@@ -5529,7 +5529,7 @@ bool callback_from_typval(Callback *const callback, const typval_T *const arg)
       if (callback->data.funcref == NULL) {
         callback->data.funcref = xstrdup(name);
       }
-      func_ref((char_u *)callback->data.funcref);
+      func_ref(callback->data.funcref);
       callback->type = kCallbackFuncref;
     }
   } else if (nlua_is_table_from_lua(arg)) {
@@ -8100,7 +8100,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, const char
       // - The text up to where the match is.
       // - The substituted text.
       // - The text after the match.
-      sublen = vim_regsub(&regmatch, (char_u *)sub, expr, (char_u *)tail, 0, REGSUB_MAGIC);
+      sublen = vim_regsub(&regmatch, sub, expr, tail, 0, REGSUB_MAGIC);
       ga_grow(&ga, (int)((end - tail) + sublen -
                          (regmatch.endp[0] - regmatch.startp[0])));
 
@@ -8108,8 +8108,8 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, const char
       int i = (int)(regmatch.startp[0] - tail);
       memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
       // add the substituted text
-      (void)vim_regsub(&regmatch, (char_u *)sub, expr,
-                       (char_u *)ga.ga_data + ga.ga_len + i, sublen,
+      (void)vim_regsub(&regmatch, sub, expr,
+                       (char *)ga.ga_data + ga.ga_len + i, sublen,
                        REGSUB_COPY | REGSUB_MAGIC);
       ga.ga_len += i + sublen - 1;
       tail = regmatch.endp[0];
diff --git a/src/nvim/eval/buffer.c b/src/nvim/eval/buffer.c
index e8eca3f854..2f37d1ba2e 100644
--- a/src/nvim/eval/buffer.c
+++ b/src/nvim/eval/buffer.c
@@ -278,9 +278,9 @@ void f_appendbufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "bufadd(expr)" function
 void f_bufadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  char_u *name = (char_u *)tv_get_string(&argvars[0]);
+  char *name = (char *)tv_get_string(&argvars[0]);
 
-  rettv->vval.v_number = buflist_add(*name == NUL ? NULL : (char *)name, 0);
+  rettv->vval.v_number = buflist_add(*name == NUL ? NULL : name, 0);
 }
 
 /// "bufexists(expr)" function
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 648e101fcd..6a677dd675 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -244,11 +244,11 @@ int call_internal_func(const char *const fname, const int argcount, typval_T *co
 }
 
 /// Invoke a method for base->method().
-int call_internal_method(const char_u *const fname, const int argcount, typval_T *const argvars,
+int call_internal_method(const char *const fname, const int argcount, typval_T *const argvars,
                          typval_T *const rettv, typval_T *const basetv)
   FUNC_ATTR_NONNULL_ALL
 {
-  const EvalFuncDef *const fdef = find_internal_func((const char *)fname);
+  const EvalFuncDef *const fdef = find_internal_func(fname);
   if (fdef == NULL) {
     return FCERR_UNKNOWN;
   } else if (fdef->base_arg == BASE_NONE) {
@@ -572,16 +572,16 @@ static void f_call(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     if (argvars[2].v_type != VAR_DICT) {
       emsg(_(e_dictreq));
       if (owned) {
-        func_unref((char_u *)func);
+        func_unref(func);
       }
       return;
     }
     selfdict = argvars[2].vval.v_dict;
   }
 
-  func_call((char_u *)func, &argvars[1], partial, selfdict, rettv);
+  func_call(func, &argvars[1], partial, selfdict, rettv);
   if (owned) {
-    func_unref((char_u *)func);
+    func_unref(func);
   }
 }
 
@@ -2248,7 +2248,7 @@ static void f_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
         assert(name != NULL);
         if (rettv->v_type == VAR_FUNC) {
-          func_ref((char_u *)name);
+          func_ref((char *)name);
         }
         if (*what == 'n' && pt->pt_name == NULL && pt->pt_func != NULL) {
           // use <SNR> instead of the byte code
@@ -2982,7 +2982,7 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   const char *const file = tv_get_string_buf_chk(&argvars[1], buf1);
   if (file != NULL && !error) {
     garray_T ga;
-    ga_init(&ga, (int)sizeof(char_u *), 10);
+    ga_init(&ga, (int)sizeof(char *), 10);
     globpath((char *)tv_get_string(&argvars[0]), (char *)file, &ga, flags);
 
     if (rettv->v_type == VAR_STRING) {
@@ -6468,7 +6468,7 @@ static void f_rpcstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   // Allocate extra memory for the argument vector and the NULL pointer
   int argvl = argsl + 2;
-  char **argv = xmalloc(sizeof(char_u *) * (size_t)argvl);
+  char **argv = xmalloc(sizeof(char *) * (size_t)argvl);
 
   // Copy program name
   argv[0] = xstrdup(argvars[0].vval.v_string);
@@ -6644,7 +6644,7 @@ static void f_searchdecl(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
   }
   if (!error && name != NULL) {
-    rettv->vval.v_number = find_decl((char_u *)name, strlen(name), locally,
+    rettv->vval.v_number = find_decl((char *)name, strlen(name), locally,
                                      thisblock, SEARCH_KEEP) == FAIL;
   }
 }
@@ -7069,11 +7069,11 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
     return;
   }
 
-  char_u *const csearch = (char_u *)tv_dict_get_string(d, "char", false);
+  char *const csearch = tv_dict_get_string(d, "char", false);
   if (csearch != NULL) {
     int pcc[MAX_MCO];
-    const int c = utfc_ptr2char((char *)csearch, pcc);
-    set_last_csearch(c, (char *)csearch, utfc_ptr2len((char *)csearch));
+    const int c = utfc_ptr2char(csearch, pcc);
+    set_last_csearch(c, csearch, utfc_ptr2len(csearch));
   }
 
   dictitem_T *di = tv_dict_find(d, S_LEN("forward"));
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 7c61a2f990..5a356813f0 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -1599,7 +1599,7 @@ void callback_free(Callback *callback)
 {
   switch (callback->type) {
   case kCallbackFuncref:
-    func_unref((char_u *)callback->data.funcref);
+    func_unref(callback->data.funcref);
     xfree(callback->data.funcref);
     break;
   case kCallbackPartial:
@@ -1628,7 +1628,7 @@ void callback_put(Callback *cb, typval_T *tv)
   case kCallbackFuncref:
     tv->v_type = VAR_FUNC;
     tv->vval.v_string = xstrdup(cb->data.funcref);
-    func_ref((char_u *)cb->data.funcref);
+    func_ref(cb->data.funcref);
     break;
   case kCallbackLua:
   // TODO(tjdevries): Unified Callback.
@@ -1654,7 +1654,7 @@ void callback_copy(Callback *dest, Callback *src)
     break;
   case kCallbackFuncref:
     dest->data.funcref = xstrdup(src->data.funcref);
-    func_ref((char_u *)src->data.funcref);
+    func_ref(src->data.funcref);
     break;
   case kCallbackLua:
     dest->data.luaref = api_new_luaref(src->data.luaref);
@@ -3019,7 +3019,7 @@ static inline int _nothing_conv_func_start(typval_T *const tv, char_u *const fun
       return OK;
     }
   } else {
-    func_unref(fun);
+    func_unref((char *)fun);
     if ((const char *)fun != tv_empty_string) {
       xfree(fun);
     }
@@ -3235,7 +3235,7 @@ void tv_free(typval_T *tv)
       partial_unref(tv->vval.v_partial);
       break;
     case VAR_FUNC:
-      func_unref((char_u *)tv->vval.v_string);
+      func_unref(tv->vval.v_string);
       FALLTHROUGH;
     case VAR_STRING:
       xfree(tv->vval.v_string);
@@ -3288,7 +3288,7 @@ void tv_copy(const typval_T *const from, typval_T *const to)
     if (from->vval.v_string != NULL) {
       to->vval.v_string = xstrdup(from->vval.v_string);
       if (from->v_type == VAR_FUNC) {
-        func_ref((char_u *)to->vval.v_string);
+        func_ref(to->vval.v_string);
       }
     }
     break;
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 41dc7d5e61..1d27826e7a 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -84,7 +84,7 @@ hashtab_T *func_tbl_get(void)
 }
 
 /// Get function arguments.
-static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int *varargs,
+static int get_function_args(char **argp, char endchar, garray_T *newargs, int *varargs,
                              garray_T *default_args, bool skip)
 {
   bool mustend = false;
@@ -106,7 +106,7 @@ static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int
 
   // Isolate the arguments: "arg1, arg2, ...)"
   bool any_default = false;
-  while (*p != (char)endchar) {
+  while (*p != endchar) {
     if (p[0] == '.' && p[1] == '.' && p[2] == '.') {
       if (varargs != NULL) {
         *varargs = true;
@@ -188,14 +188,14 @@ static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int
       }
     }
     p = skipwhite(p);
-    if (mustend && *p != (char)endchar) {
+    if (mustend && *p != endchar) {
       if (!skip) {
         semsg(_(e_invarg2), *argp);
       }
       break;
     }
   }
-  if (*p != (char)endchar) {
+  if (*p != endchar) {
     goto err_ret;
   }
   p++;  // skip "endchar"
@@ -229,12 +229,12 @@ static void register_closure(ufunc_T *fp)
 }
 
 /// @return  a name for a lambda.  Returned in static memory.
-char_u *get_lambda_name(void)
+char *get_lambda_name(void)
 {
-  static char_u name[30];
+  static char name[30];
   static int lambda_no = 0;
 
-  snprintf((char *)name, sizeof(name), "<lambda>%d", ++lambda_no);
+  snprintf(name, sizeof(name), "<lambda>%d", ++lambda_no);
   return name;
 }
 
@@ -308,7 +308,7 @@ int get_lambda_tv(char **arg, typval_T *rettv, bool evaluate)
     char *p;
     garray_T newlines;
 
-    char *name = (char *)get_lambda_name();
+    char *name = get_lambda_name();
 
     fp = xcalloc(1, offsetof(ufunc_T, uf_name) + strlen(name) + 1);
     pt = xcalloc(1, sizeof(partial_T));
@@ -1226,7 +1226,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
 /// For the first we only count the name stored in func_hashtab as a reference,
 /// using function() does not count as a reference, because the function is
 /// looked up by name.
-static bool func_name_refcount(const char_u *name)
+static bool func_name_refcount(const char *name)
 {
   return isdigit((uint8_t)(*name)) || *name == '<';
 }
@@ -1319,7 +1319,7 @@ void free_all_functions(void)
         // Only free functions that are not refcounted, those are
         // supposed to be freed when no longer referenced.
         fp = HI2UF(hi);
-        if (func_name_refcount((char_u *)fp->uf_name)) {
+        if (func_name_refcount(fp->uf_name)) {
           skipped++;
         } else {
           changed = func_hashtab.ht_changed;
@@ -1345,7 +1345,7 @@ void free_all_functions(void)
         // Only free functions that are not refcounted, those are
         // supposed to be freed when no longer referenced.
         fp = HI2UF(hi);
-        if (func_name_refcount((char_u *)fp->uf_name)) {
+        if (func_name_refcount(fp->uf_name)) {
           skipped++;
         } else {
           func_free(fp);
@@ -1382,7 +1382,7 @@ static bool builtin_function(const char *name, int len)
   return p == NULL;
 }
 
-int func_call(char_u *name, typval_T *args, partial_T *partial, dict_T *selfdict, typval_T *rettv)
+int func_call(char *name, typval_T *args, partial_T *partial, dict_T *selfdict, typval_T *rettv)
 {
   typval_T argv[MAX_FUNC_ARGS + 1];
   int argc = 0;
@@ -1404,7 +1404,7 @@ int func_call(char_u *name, typval_T *args, partial_T *partial, dict_T *selfdict
   funcexe.fe_evaluate = true;
   funcexe.fe_partial = partial;
   funcexe.fe_selfdict = selfdict;
-  r = call_func((char *)name, -1, rettv, argc, argv, &funcexe);
+  r = call_func(name, -1, rettv, argc, argv, &funcexe);
 
 func_call_skip_call:
   // Free the arguments.
@@ -1435,30 +1435,30 @@ varnumber_T callback_call_retnr(Callback *callback, int argcount, typval_T *argv
 
 /// Give an error message for the result of a function.
 /// Nothing if "error" is FCERR_NONE.
-static void user_func_error(int error, const char_u *name)
+static void user_func_error(int error, const char *name)
   FUNC_ATTR_NONNULL_ALL
 {
   switch (error) {
   case FCERR_UNKNOWN:
-    emsg_funcname(N_("E117: Unknown function: %s"), (char *)name);
+    emsg_funcname(N_("E117: Unknown function: %s"), name);
     break;
   case FCERR_NOTMETHOD:
-    emsg_funcname(N_("E276: Cannot use function as a method: %s"), (char *)name);
+    emsg_funcname(N_("E276: Cannot use function as a method: %s"), name);
     break;
   case FCERR_DELETED:
-    emsg_funcname(N_("E933: Function was deleted: %s"), (char *)name);
+    emsg_funcname(N_("E933: Function was deleted: %s"), name);
     break;
   case FCERR_TOOMANY:
-    emsg_funcname(_(e_toomanyarg), (char *)name);
+    emsg_funcname(_(e_toomanyarg), name);
     break;
   case FCERR_TOOFEW:
-    emsg_funcname(N_("E119: Not enough arguments for function: %s"), (char *)name);
+    emsg_funcname(N_("E119: Not enough arguments for function: %s"), name);
     break;
   case FCERR_SCRIPT:
-    emsg_funcname(N_("E120: Using <SID> not in a script context: %s"), (char *)name);
+    emsg_funcname(N_("E120: Using <SID> not in a script context: %s"), name);
     break;
   case FCERR_DICT:
-    emsg_funcname(N_("E725: Calling dict function without Dictionary: %s"), (char *)name);
+    emsg_funcname(N_("E725: Calling dict function without Dictionary: %s"), name);
     break;
   }
 }
@@ -1612,7 +1612,7 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
     } else if (funcexe->fe_basetv != NULL) {
       // expr->method(): Find the method name in the table, call its
       // implementation with the base as one of the arguments.
-      error = call_internal_method((char_u *)fname, argcount, argvars, rettv,
+      error = call_internal_method(fname, argcount, argvars, rettv,
                                    funcexe->fe_basetv);
     } else {
       // Find the function name in the table, call its implementation.
@@ -1636,7 +1636,7 @@ theend:
   // Report an error unless the argument evaluation or function call has been
   // cancelled due to an aborting error, an interrupt, or an exception.
   if (!aborting()) {
-    user_func_error(error, (name != NULL) ? (char_u *)name : (char_u *)funcname);
+    user_func_error(error, (name != NULL) ? name : funcname);
   }
 
   // clear the copies made from the partial
@@ -1724,7 +1724,7 @@ static void list_func_head(ufunc_T *fp, int indent, bool force)
 /// @param partial  return: partial of a FuncRef
 ///
 /// @return the function name in allocated memory, or NULL for failure.
-char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, partial_T **partial)
+char *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, partial_T **partial)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char *name = NULL;
@@ -1745,7 +1745,7 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
       && (*pp)[2] == KE_SNR) {
     *pp += 3;
     len = get_id_len((const char **)pp) + 3;
-    return (char_u *)xmemdupz(start, (size_t)len);
+    return xmemdupz(start, (size_t)len);
   }
 
   // A name starting with "<SID>" or "<SNR>" is local to a script.  But
@@ -1924,7 +1924,7 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
 
 theend:
   clear_lval(&lv);
-  return (char_u *)name;
+  return name;
 }
 
 /// If the "funcname" starts with "s:" or "<SID>", then expands it to the
@@ -1976,7 +1976,7 @@ char *save_function_name(char **name, bool skip, int flags, funcdict_T *fudi)
       CLEAR_POINTER(fudi);
     }
   } else {
-    saved = (char *)trans_function_name(&p, skip, flags, fudi, NULL);
+    saved = trans_function_name(&p, skip, flags, fudi, NULL);
   }
   *name = p;
   return saved;
@@ -2001,7 +2001,7 @@ static void list_functions(regmatch_T *regmatch)
       if ((fp->uf_flags & FC_DEAD) == 0
           && (regmatch == NULL
               ? (!message_filtered((char *)fp->uf_name)
-                 && !func_name_refcount((char_u *)fp->uf_name))
+                 && !func_name_refcount(fp->uf_name))
               : (!isdigit((uint8_t)(*fp->uf_name))
                  && vim_regexec(regmatch, (char *)fp->uf_name, 0)))) {
         list_func_head(fp, false, false);
@@ -2708,7 +2708,7 @@ bool function_exists(const char *const name, bool no_deref)
   if (no_deref) {
     flag |= TFN_NO_DEREF;
   }
-  char *const p = (char *)trans_function_name((char **)&nm, false, flag, NULL, NULL);
+  char *const p = trans_function_name((char **)&nm, false, flag, NULL, NULL);
   nm = skipwhite(nm);
 
   // Only accept "funcname", "funcname ", "funcname (..." and
@@ -2770,7 +2770,7 @@ void ex_delfunction(exarg_T *eap)
 {
   ufunc_T *fp = NULL;
   char *p;
-  char_u *name;
+  char *name;
   funcdict_T fudi;
 
   p = eap->arg;
@@ -2800,7 +2800,7 @@ void ex_delfunction(exarg_T *eap)
     return;
   }
   if (!eap->skip) {
-    fp = find_func(name);
+    fp = find_func((char_u *)name);
   }
   xfree(name);
 
@@ -2833,7 +2833,7 @@ void ex_delfunction(exarg_T *eap)
       // it and the refcount is more than one, it should be kept.
       // A numbered function or lambda should be kept if the refcount is
       // one or more.
-      if (fp->uf_refcount > (func_name_refcount((char_u *)fp->uf_name) ? 0 : 1)) {
+      if (fp->uf_refcount > (func_name_refcount(fp->uf_name) ? 0 : 1)) {
         // Function is still referenced somewhere. Don't free it but
         // do remove it from the hashtable.
         if (func_remove(fp)) {
@@ -2849,7 +2849,7 @@ void ex_delfunction(exarg_T *eap)
 
 /// Unreference a Function: decrement the reference count and free it when it
 /// becomes zero.
-void func_unref(char_u *name)
+void func_unref(char *name)
 {
   ufunc_T *fp = NULL;
 
@@ -2857,7 +2857,7 @@ void func_unref(char_u *name)
     return;
   }
 
-  fp = find_func(name);
+  fp = find_func((char_u *)name);
   if (fp == NULL && isdigit((uint8_t)(*name))) {
 #ifdef EXITFREE
     if (!entered_free_all_mem) {
@@ -2891,14 +2891,14 @@ void func_ptr_unref(ufunc_T *fp)
 }
 
 /// Count a reference to a Function.
-void func_ref(char_u *name)
+void func_ref(char *name)
 {
   ufunc_T *fp;
 
   if (name == NULL || !func_name_refcount(name)) {
     return;
   }
-  fp = find_func(name);
+  fp = find_func((char_u *)name);
   if (fp != NULL) {
     (fp->uf_refcount)++;
   } else if (isdigit((uint8_t)(*name))) {
@@ -3018,7 +3018,7 @@ void ex_call(exarg_T *eap)
     return;
   }
 
-  tofree = (char *)trans_function_name(&arg, false, TFN_INT, &fudi, &partial);
+  tofree = trans_function_name(&arg, false, TFN_INT, &fudi, &partial);
   if (fudi.fd_newkey != NULL) {
     // Still need to give an error message for missing key.
     semsg(_(e_dictkey), fudi.fd_newkey);
@@ -3328,7 +3328,7 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
       // be referenced elsewhere.
       if (ret_pt->pt_name != NULL) {
         pt->pt_name = xstrdup(ret_pt->pt_name);
-        func_ref((char_u *)pt->pt_name);
+        func_ref(pt->pt_name);
       } else {
         pt->pt_func = ret_pt->pt_func;
         func_ptr_ref(pt->pt_func);
@@ -3349,9 +3349,9 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
 }
 
 /// @return  the name of the executed function.
-char_u *func_name(void *cookie)
+char *func_name(void *cookie)
 {
-  return (char_u *)((funccall_T *)cookie)->func->uf_name;
+  return ((funccall_T *)cookie)->func->uf_name;
 }
 
 /// @return  the address holding the next breakpoint line for a funccall cookie.
@@ -3610,7 +3610,7 @@ bool set_ref_in_functions(int copyID)
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
       fp = HI2UF(hi);
-      if (!func_name_refcount((char_u *)fp->uf_name)
+      if (!func_name_refcount(fp->uf_name)
           && set_ref_in_func(NULL, fp, copyID)) {
         return true;
       }
@@ -3636,7 +3636,7 @@ bool set_ref_in_func_args(int copyID)
 /// "ht_stack" is used to add hashtabs to be marked.  Can be NULL.
 ///
 /// @return  true if setting references failed somehow.
-bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
+bool set_ref_in_func(char *name, ufunc_T *fp_in, int copyID)
 {
   ufunc_T *fp = fp_in;
   funccall_T *fc;
@@ -3650,7 +3650,7 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
   }
 
   if (fp_in == NULL) {
-    fname = fname_trans_sid((char *)name, fname_buf, &tofree, &error);
+    fname = fname_trans_sid(name, fname_buf, &tofree, &error);
     fp = find_func((char_u *)fname);
   }
   if (fp != NULL) {
@@ -3663,9 +3663,9 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
 }
 
 /// Registers a luaref as a lambda.
-char_u *register_luafunc(LuaRef ref)
+char *register_luafunc(LuaRef ref)
 {
-  char *name = (char *)get_lambda_name();
+  char *name = get_lambda_name();
   ufunc_T *fp = xcalloc(1, offsetof(ufunc_T, uf_name) + strlen(name) + 1);
 
   fp->uf_refcount = 1;
@@ -3679,5 +3679,5 @@ char_u *register_luafunc(LuaRef ref)
   hash_add(&func_hashtab, UF2HIKEY(fp));
 
   // coverity[leaked_storage]
-  return (char_u *)fp->uf_name;
+  return fp->uf_name;
 }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 4ea11dd32a..6e888d9dcf 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -158,7 +158,7 @@ void do_ascii(const exarg_T *const eap)
     char buf2[20];
     buf2[0] = NUL;
 
-    dig = (char *)get_digraph_for_char(cval);
+    dig = get_digraph_for_char(cval);
     if (dig != NULL) {
       iobuff_len += (size_t)vim_snprintf(IObuff + iobuff_len,
                                          sizeof(IObuff) - iobuff_len,
@@ -206,7 +206,7 @@ void do_ascii(const exarg_T *const eap)
     }
     iobuff_len += (size_t)utf_char2bytes(c, IObuff + iobuff_len);
 
-    dig = (char *)get_digraph_for_char(c);
+    dig = get_digraph_for_char(c);
     if (dig != NULL) {
       iobuff_len += (size_t)vim_snprintf(IObuff + iobuff_len,
                                          sizeof(IObuff) - iobuff_len,
@@ -3895,7 +3895,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           // When it fails sublen is zero.
           sublen = vim_regsub_multi(&regmatch,
                                     sub_firstlnum - regmatch.startpos[0].lnum,
-                                    (char_u *)sub, (char_u *)sub_firstline, 0,
+                                    sub, sub_firstline, 0,
                                     REGSUB_BACKSLASH
                                     | (magic_isset() ? REGSUB_MAGIC : 0));
           textlock--;
@@ -3938,7 +3938,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           textlock++;
           (void)vim_regsub_multi(&regmatch,
                                  sub_firstlnum - regmatch.startpos[0].lnum,
-                                 (char_u *)sub, (char_u *)new_end, sublen,
+                                 sub, new_end, sublen,
                                  REGSUB_COPY | REGSUB_BACKSLASH
                                  | (magic_isset() ? REGSUB_MAGIC : 0));
           textlock--;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index ec2ff652b0..08d4065e98 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -369,7 +369,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
   // Get the function or script name and the address where the next breakpoint
   // line and the debug tick for a function or script are stored.
   if (getline_is_func) {
-    fname = (char *)func_name(real_cookie);
+    fname = func_name(real_cookie);
     breakpoint = func_breakpoint(real_cookie);
     dbg_tick = func_dbg_tick(real_cookie);
   } else if (getline_equal(fgetline, cookie, getsourceline)) {
@@ -3812,8 +3812,8 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
 #endif
 
       for (l = repl; *l; l++) {
-        if (vim_strchr((char *)ESCAPE_CHARS, (uint8_t)(*l)) != NULL) {
-          l = vim_strsave_escaped(repl, (char *)ESCAPE_CHARS);
+        if (vim_strchr(ESCAPE_CHARS, (uint8_t)(*l)) != NULL) {
+          l = vim_strsave_escaped(repl, ESCAPE_CHARS);
           xfree(repl);
           repl = l;
           break;
@@ -4976,8 +4976,8 @@ void ex_splitview(exarg_T *eap)
   }
 
   if (eap->cmdidx == CMD_sfind || eap->cmdidx == CMD_tabfind) {
-    fname = (char *)find_file_in_path(eap->arg, strlen(eap->arg),
-                                      FNAME_MESS, true, curbuf->b_ffname);
+    fname = find_file_in_path(eap->arg, strlen(eap->arg),
+                              FNAME_MESS, true, curbuf->b_ffname);
     if (fname == NULL) {
       goto theend;
     }
@@ -4987,7 +4987,7 @@ void ex_splitview(exarg_T *eap)
   // Either open new tab page or split the window.
   if (use_tab) {
     if (win_new_tabpage(cmdmod.cmod_tab != 0 ? cmdmod.cmod_tab : eap->addr_count == 0
-                        ? 0 : (int)eap->line2 + 1, (char_u *)eap->arg) != FAIL) {
+                        ? 0 : (int)eap->line2 + 1, eap->arg) != FAIL) {
       do_exedit(eap, old_curwin);
       apply_autocmds(EVENT_TABNEWENTERED, NULL, NULL, false, curbuf);
 
@@ -5169,15 +5169,15 @@ static void ex_resize(exarg_T *eap)
 /// ":find [+command] <file>" command.
 static void ex_find(exarg_T *eap)
 {
-  char *fname = (char *)find_file_in_path(eap->arg, strlen(eap->arg),
-                                          FNAME_MESS, true, curbuf->b_ffname);
+  char *fname = find_file_in_path(eap->arg, strlen(eap->arg),
+                                  FNAME_MESS, true, curbuf->b_ffname);
   if (eap->addr_count > 0) {
     // Repeat finding the file "count" times.  This matters when it
     // appears several times in the path.
     linenr_T count = eap->line2;
     while (fname != NULL && --count > 0) {
       xfree(fname);
-      fname = (char *)find_file_in_path(NULL, 0, FNAME_MESS, false, curbuf->b_ffname);
+      fname = find_file_in_path(NULL, 0, FNAME_MESS, false, curbuf->b_ffname);
     }
   }
 
@@ -6845,7 +6845,7 @@ char_u *eval_vars(char *src, const char_u *srcstart, size_t *usedlen, linenr_T *
       break;
 
     case SPEC_CFILE:            // file name under cursor
-      result = (char *)file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
+      result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
       if (result == NULL) {
         *errormsg = "";
         return NULL;
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index a0a55de729..c62142310d 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1474,7 +1474,7 @@ static int command_line_erase_chars(CommandLineState *s)
   }
 
   if (s->c == K_DEL) {
-    ccline.cmdpos += mb_off_next((char_u *)ccline.cmdbuff,
+    ccline.cmdpos += mb_off_next(ccline.cmdbuff,
                                  ccline.cmdbuff + ccline.cmdpos);
   }
 
@@ -3969,8 +3969,8 @@ char *vim_strsave_fnameescape(const char *const fname, const int what)
 {
 #ifdef BACKSLASH_IN_FILENAME
 # define PATH_ESC_CHARS " \t\n*?[{`%#'\"|!<"
-# define BUFFER_ESC_CHARS ((char_u *)" \t\n*?[`%#'\"|!<")
-  char_u buf[sizeof(PATH_ESC_CHARS)];
+# define BUFFER_ESC_CHARS (" \t\n*?[`%#'\"|!<")
+  char buf[sizeof(PATH_ESC_CHARS)];
   int j = 0;
 
   // Don't escape '[', '{' and '!' if they are in 'isfname' and for the
@@ -3982,8 +3982,7 @@ char *vim_strsave_fnameescape(const char *const fname, const int what)
     }
   }
   buf[j] = NUL;
-  char *p = (char *)vim_strsave_escaped((const char_u *)fname,
-                                        (const char_u *)buf);
+  char *p = vim_strsave_escaped(fname, buf);
 #else
 # define PATH_ESC_CHARS " \t\n*?[{`$\\%#'\"|!<"
 # define SHELL_ESC_CHARS " \t\n*?[{`$\\%#'\"|!<>();&"
@@ -4290,7 +4289,7 @@ char *check_cedit(void)
   if (*p_cedit == NUL) {
     cedit_key = -1;
   } else {
-    n = string_to_key((char_u *)p_cedit);
+    n = string_to_key(p_cedit);
     if (vim_isprintc(n)) {
       return e_invarg;
     }
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index d0280b3571..02a33f8fd3 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -551,7 +551,7 @@ void vim_findfile_cleanup(void *ctx)
 ///
 /// @return  a pointer to an allocated file name or,
 ///          NULL if nothing found.
-char_u *vim_findfile(void *search_ctx_arg)
+char *vim_findfile(void *search_ctx_arg)
 {
   char *file_path;
   char *rest_of_wildcards;
@@ -829,7 +829,7 @@ char_u *vim_findfile(void *search_ctx_arg)
                   verbose_leave_scroll();
                 }
 #endif
-                return (char_u *)file_path;
+                return file_path;
               }
 
               // Not found or found already, try next suffix.
@@ -1287,13 +1287,13 @@ static int ff_path_in_stoplist(char *path, int path_len, char **stopdirs_v)
 /// @param rel_fname  file name searching relative to
 ///
 /// @return  an allocated string for the file name.  NULL for error.
-char_u *find_file_in_path(char *ptr, size_t len, int options, int first, char *rel_fname)
+char *find_file_in_path(char *ptr, size_t len, int options, int first, char *rel_fname)
 {
-  return (char_u *)find_file_in_path_option(ptr, len, options, first,
-                                            (*curbuf->b_p_path == NUL
-                                             ? (char *)p_path
-                                             : curbuf->b_p_path),
-                                            FINDFILE_BOTH, rel_fname, curbuf->b_p_sua);
+  return find_file_in_path_option(ptr, len, options, first,
+                                  (*curbuf->b_p_path == NUL
+                                   ? (char *)p_path
+                                   : curbuf->b_p_path),
+                                  FINDFILE_BOTH, rel_fname, curbuf->b_p_sua);
 }
 
 static char *ff_file_to_find = NULL;
@@ -1322,10 +1322,10 @@ void free_findfile(void)
 /// @param rel_fname  file name searching relative to
 ///
 /// @return  an allocated string for the file name.  NULL for error.
-char_u *find_directory_in_path(char_u *ptr, size_t len, int options, char_u *rel_fname)
+char *find_directory_in_path(char *ptr, size_t len, int options, char *rel_fname)
 {
-  return (char_u *)find_file_in_path_option((char *)ptr, len, options, true, (char *)p_cdpath,
-                                            FINDFILE_DIR, (char *)rel_fname, "");
+  return find_file_in_path_option(ptr, len, options, true, (char *)p_cdpath,
+                                  FINDFILE_DIR, rel_fname, "");
 }
 
 /// @param ptr  file name
@@ -1446,7 +1446,7 @@ char *find_file_in_path_option(char *ptr, size_t len, int options, int first, ch
 
     for (;;) {
       if (did_findfile_init) {
-        file_name = (char *)vim_findfile(fdip_search_ctx);
+        file_name = vim_findfile(fdip_search_ctx);
         if (file_name != NULL) {
           break;
         }
@@ -1610,8 +1610,8 @@ int vim_chdirfile(char *fname, CdCause cause)
 /// Change directory to "new_dir". Search 'cdpath' for relative directory names.
 int vim_chdir(char *new_dir)
 {
-  char *dir_name = (char *)find_directory_in_path((char_u *)new_dir, strlen(new_dir),
-                                                  FNAME_MESS, (char_u *)curbuf->b_ffname);
+  char *dir_name = find_directory_in_path(new_dir, strlen(new_dir),
+                                          FNAME_MESS, curbuf->b_ffname);
   if (dir_name == NULL) {
     return -1;
   }
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 3a7db22d2f..78fe8a3ab3 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -105,7 +105,7 @@ enum {
 // Structure to pass arguments from buf_write() to buf_write_bytes().
 struct bw_info {
   int bw_fd;                     // file descriptor
-  char_u *bw_buf;           // buffer with data to be written
+  char *bw_buf;                  // buffer with data to be written
   int bw_len;                    // length of data
 #ifdef HAS_BW_FLAGS
   int bw_flags;                  // FIO_ flags
@@ -113,7 +113,7 @@ struct bw_info {
   char_u bw_rest[CONV_RESTLEN];  // not converted bytes
   int bw_restlen;                // nr of bytes in bw_rest[]
   int bw_first;                  // first write call
-  char_u *bw_conv_buf;           // buffer for writing converted chars
+  char *bw_conv_buf;             // buffer for writing converted chars
   size_t bw_conv_buflen;         // size of bw_conv_buf
   int bw_conv_error;             // set for conversion error
   linenr_T bw_conv_error_lnum;   // first line with error or zero
@@ -835,14 +835,14 @@ retry:
       // appears not to handle this correctly.  This works just like
       // conversion to UTF-8 except how the resulting character is put in
       // the buffer.
-      fio_flags = get_fio_flags((char_u *)fenc);
+      fio_flags = get_fio_flags(fenc);
     }
 
 #ifdef HAVE_ICONV
     // Try using iconv() if we can't convert internally.
     if (fio_flags == 0
         && !did_iconv) {
-      iconv_fd = (iconv_t)my_iconv_open((char_u *)"utf-8", (char_u *)fenc);
+      iconv_fd = (iconv_t)my_iconv_open("utf-8", fenc);
     }
 #endif
 
@@ -1107,7 +1107,7 @@ retry:
               || (!curbuf->b_p_bomb
                   && tmpname == NULL
                   && (*fenc == 'u' || *fenc == NUL)))) {
-        char_u *ccname;
+        char *ccname;
         int blen = 0;
 
         // no BOM detection in a short file or in binary mode
@@ -1115,7 +1115,7 @@ retry:
           ccname = NULL;
         } else {
           ccname = check_for_bom((char_u *)ptr, size, &blen,
-                                 fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags((char_u *)fenc));
+                                 fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags(fenc));
         }
         if (ccname != NULL) {
           // Remove BOM from the text
@@ -1137,7 +1137,7 @@ retry:
             if (fenc_alloced) {
               xfree(fenc);
             }
-            fenc = (char *)ccname;
+            fenc = ccname;
             fenc_alloced = false;
           }
           // retry reading without getting new bytes or rewinding
@@ -1193,7 +1193,7 @@ retry:
         if (from_size > 0) {
           // Some remaining characters, keep them for the next
           // round.
-          memmove(conv_rest, (char_u *)fromp, from_size);
+          memmove(conv_rest, fromp, from_size);
           conv_restlen = (int)from_size;
         }
 
@@ -1394,7 +1394,7 @@ retry:
             // an incomplete character at the end though, the next
             // read() will get the next bytes, we'll check it
             // then.
-            l = utf_ptr2len_len(p, todo);
+            l = utf_ptr2len_len((char *)p, todo);
             if (l > todo && !incomplete_tail) {
               // Avoid retrying with a different encoding when
               // a truncated file is more likely, or attempting
@@ -2566,7 +2566,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 #ifdef HAVE_ACL
   // For systems that support ACL: get the ACL from the original file.
   if (!newfile) {
-    acl = os_get_acl((char_u *)fname);
+    acl = os_get_acl(fname);
   }
 #endif
 
@@ -2806,7 +2806,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
                           (double)file_info_old.stat.st_mtim.tv_sec);
 #endif
 #ifdef HAVE_ACL
-          os_set_acl((char_u *)backup, acl);
+          os_set_acl(backup, acl);
 #endif
           SET_ERRMSG(NULL);
           break;
@@ -2980,7 +2980,7 @@ nobackup:
   // Latin1 to Unicode conversion.  This is handled in buf_write_bytes().
   // Prepare the flags for it and allocate bw_conv_buf when needed.
   if (converted) {
-    wb_flags = get_fio_flags((char_u *)fenc);
+    wb_flags = get_fio_flags(fenc);
     if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8)) {
       // Need to allocate a buffer to translate into.
       if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8)) {
@@ -2999,7 +2999,7 @@ nobackup:
 #ifdef HAVE_ICONV
     // Use iconv() conversion when conversion is needed and it's not done
     // internally.
-    write_info.bw_iconv_fd = (iconv_t)my_iconv_open((char_u *)fenc, (char_u *)"utf-8");
+    write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc, "utf-8");
     if (write_info.bw_iconv_fd != (iconv_t)-1) {
       // We're going to use iconv(), allocate a buffer to convert in.
       write_info.bw_conv_buflen = (size_t)bufsize * ICONV_MULT;
@@ -3151,7 +3151,7 @@ restore_backup:
     }
     SET_ERRMSG(NULL);
 
-    write_info.bw_buf = (char_u *)buffer;
+    write_info.bw_buf = buffer;
     nchars = 0;
 
     // use "++bin", "++nobin" or 'binary'
@@ -3164,7 +3164,7 @@ restore_backup:
     // Skip the BOM when appending and the file already existed, the BOM
     // only makes sense at the start of the file.
     if (buf->b_p_bomb && !write_bin && (!append || perm < 0)) {
-      write_info.bw_len = make_bom((char_u *)buffer, (char_u *)fenc);
+      write_info.bw_len = make_bom((char_u *)buffer, fenc);
       if (write_info.bw_len > 0) {
         // don't convert
         write_info.bw_flags = FIO_NOCONVERT | wb_flags;
@@ -3342,7 +3342,7 @@ restore_backup:
     // Probably need to set the ACL before changing the user (can't set the
     // ACL on a file the user doesn't own).
     if (!backup_copy) {
-      os_set_acl((char_u *)wfname, acl);
+      os_set_acl(wfname, acl);
     }
 #endif
 
@@ -3812,7 +3812,7 @@ static bool time_differs(const FileInfo *file_info, long mtime, long mtime_ns) F
 static int buf_write_bytes(struct bw_info *ip)
 {
   int wlen;
-  char_u *buf = ip->bw_buf;        // data to write
+  char *buf = ip->bw_buf;        // data to write
   int len = ip->bw_len;                 // length of data
 #ifdef HAS_BW_FLAGS
   int flags = ip->bw_flags;             // extra flags
@@ -3820,7 +3820,7 @@ static int buf_write_bytes(struct bw_info *ip)
 
   // Skip conversion when writing the BOM.
   if (!(flags & FIO_NOCONVERT)) {
-    char_u *p;
+    char *p;
     unsigned c;
     int n;
 
@@ -3828,7 +3828,7 @@ static int buf_write_bytes(struct bw_info *ip)
       // Convert latin1 in the buffer to UTF-8 in the file.
       p = ip->bw_conv_buf;              // translate to buffer
       for (wlen = 0; wlen < len; wlen++) {
-        p += utf_char2bytes(buf[wlen], (char *)p);
+        p += utf_char2bytes((uint8_t)buf[wlen], p);
       }
       buf = ip->bw_conv_buf;
       len = (int)(p - ip->bw_conv_buf);
@@ -3852,7 +3852,7 @@ static int buf_write_bytes(struct bw_info *ip)
             l = len;
           }
           memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
-          n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
+          n = utf_ptr2len_len((char *)ip->bw_rest, ip->bw_restlen + l);
           if (n > ip->bw_restlen + len) {
             // We have an incomplete byte sequence at the end to
             // be written.  We can't convert it without the
@@ -3892,9 +3892,9 @@ static int buf_write_bytes(struct bw_info *ip)
             break;
           }
           if (n > 1) {
-            c = (unsigned)utf_ptr2char((char *)buf + wlen);
+            c = (unsigned)utf_ptr2char(buf + wlen);
           } else {
-            c = buf[wlen];
+            c = (uint8_t)buf[wlen];
           }
         }
 
@@ -3929,17 +3929,17 @@ static int buf_write_bytes(struct bw_info *ip)
         // the bytes of the current call.  Use the end of the
         // conversion buffer for this.
         fromlen = (size_t)len + (size_t)ip->bw_restlen;
-        fp = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
+        fp = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
         memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen);
         memmove(fp + ip->bw_restlen, buf, (size_t)len);
         from = fp;
         tolen = ip->bw_conv_buflen - fromlen;
       } else {
-        from = (const char *)buf;
+        from = buf;
         fromlen = (size_t)len;
         tolen = ip->bw_conv_buflen;
       }
-      to = (char *)ip->bw_conv_buf;
+      to = ip->bw_conv_buf;
 
       if (ip->bw_first) {
         size_t save_len = tolen;
@@ -3950,7 +3950,7 @@ static int buf_write_bytes(struct bw_info *ip)
         // There is a bug in iconv() on Linux (which appears to be
         // wide-spread) which sets "to" to NULL and messes up "tolen".
         if (to == NULL) {
-          to = (char *)ip->bw_conv_buf;
+          to = ip->bw_conv_buf;
           tolen = save_len;
         }
         ip->bw_first = false;
@@ -3971,7 +3971,7 @@ static int buf_write_bytes(struct bw_info *ip)
       ip->bw_restlen = (int)fromlen;
 
       buf = ip->bw_conv_buf;
-      len = (int)((char_u *)to - ip->bw_conv_buf);
+      len = (int)(to - ip->bw_conv_buf);
     }
 #endif
   }
@@ -3991,9 +3991,9 @@ static int buf_write_bytes(struct bw_info *ip)
 /// @param flags FIO_ flags that specify which encoding to use
 ///
 /// @return true for an error, false when it's OK.
-static bool ucs2bytes(unsigned c, char_u **pp, int flags) FUNC_ATTR_NONNULL_ALL
+static bool ucs2bytes(unsigned c, char **pp, int flags) FUNC_ATTR_NONNULL_ALL
 {
-  char_u *p = *pp;
+  char_u *p = (char_u *)(*pp);
   bool error = false;
   int cc;
 
@@ -4047,7 +4047,7 @@ static bool ucs2bytes(unsigned c, char_u **pp, int flags) FUNC_ATTR_NONNULL_ALL
     }
   }
 
-  *pp = p;
+  *pp = (char *)p;
   return error;
 }
 
@@ -4070,8 +4070,8 @@ static bool need_conversion(const char *fenc)
   } else {
     // Ignore difference between "ansi" and "latin1", "ucs-4" and
     // "ucs-4be", etc.
-    enc_flags = get_fio_flags((char_u *)p_enc);
-    fenc_flags = get_fio_flags((char_u *)fenc);
+    enc_flags = get_fio_flags(p_enc);
+    fenc_flags = get_fio_flags(fenc);
     same_encoding = (enc_flags != 0 && fenc_flags == enc_flags);
   }
   if (same_encoding) {
@@ -4089,14 +4089,14 @@ static bool need_conversion(const char *fenc)
 /// use 'encoding'.
 ///
 /// @param name string to check for encoding
-static int get_fio_flags(const char_u *name)
+static int get_fio_flags(const char *name)
 {
   int prop;
 
   if (*name == NUL) {
-    name = (char_u *)p_enc;
+    name = p_enc;
   }
-  prop = enc_canon_props((char *)name);
+  prop = enc_canon_props(name);
   if (prop & ENC_UNICODE) {
     if (prop & ENC_2BYTE) {
       if (prop & ENC_ENDIAN_L) {
@@ -4130,7 +4130,7 @@ static int get_fio_flags(const char_u *name)
 ///
 /// @return  the name of the encoding and set "*lenp" to the length or,
 ///          NULL when no BOM found.
-static char_u *check_for_bom(const char_u *p, long size, int *lenp, int flags)
+static char *check_for_bom(const char_u *p, long size, int *lenp, int flags)
 {
   char *name = NULL;
   int len = 2;
@@ -4167,16 +4167,16 @@ static char_u *check_for_bom(const char_u *p, long size, int *lenp, int flags)
   }
 
   *lenp = len;
-  return (char_u *)name;
+  return name;
 }
 
 /// Generate a BOM in "buf[4]" for encoding "name".
 ///
 /// @return  the length of the BOM (zero when no BOM).
-static int make_bom(char_u *buf, char_u *name)
+static int make_bom(char_u *buf, char *name)
 {
   int flags;
-  char_u *p;
+  char *p;
 
   flags = get_fio_flags(name);
 
@@ -4191,9 +4191,9 @@ static int make_bom(char_u *buf, char_u *name)
     buf[2] = 0xbf;
     return 3;
   }
-  p = buf;
+  p = (char *)buf;
   (void)ucs2bytes(0xfeff, &p, flags);
-  return (int)(p - buf);
+  return (int)((char_u *)p - buf);
 }
 
 /// Shorten filename of a buffer.
@@ -4232,9 +4232,9 @@ void shorten_buf_fname(buf_T *buf, char *dirname, int force)
 /// Shorten filenames for all buffers.
 void shorten_fnames(int force)
 {
-  char_u dirname[MAXPATHL];
+  char dirname[MAXPATHL];
 
-  os_dirname((char *)dirname, MAXPATHL);
+  os_dirname(dirname, MAXPATHL);
   FOR_ALL_BUFFERS(buf) {
     shorten_buf_fname(buf, (char *)dirname, force);
 
@@ -4597,7 +4597,7 @@ int vim_rename(const char *from, const char *to)
   perm = os_getperm(from);
 #ifdef HAVE_ACL
   // For systems that support ACL: get the ACL from the original file.
-  acl = os_get_acl((char_u *)from);
+  acl = os_get_acl(from);
 #endif
   fd_in = os_open((char *)from, O_RDONLY, 0);
   if (fd_in < 0) {
@@ -4650,7 +4650,7 @@ int vim_rename(const char *from, const char *to)
   os_setperm((const char *)to, perm);
 #endif
 #ifdef HAVE_ACL
-  os_set_acl((char_u *)to, acl);
+  os_set_acl(to, acl);
   os_free_acl(acl);
 #endif
   if (errmsg != NULL) {
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 43b1d780be..7da8d12f4b 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -774,7 +774,7 @@ EXTERN bool g_tag_at_cursor INIT(= false);  // whether the tag command comes
 
 EXTERN int replace_offset INIT(= 0);        // offset for replace_push()
 
-EXTERN char_u *escape_chars INIT(= (char_u *)" \t\\\"|");  // need backslash in cmd line
+EXTERN char *escape_chars INIT(= " \t\\\"|");  // need backslash in cmd line
 
 EXTERN int keep_help_flag INIT(= false);  // doing :ta from help file
 
@@ -825,7 +825,7 @@ EXTERN int cmdwin_type INIT(= 0);    ///< type of cmdline window or 0
 EXTERN int cmdwin_result INIT(= 0);  ///< result of cmdline window or 0
 EXTERN int cmdwin_level INIT(= 0);   ///< cmdline recursion level
 
-EXTERN char_u no_lines_msg[] INIT(= N_("--No lines in buffer--"));
+EXTERN char no_lines_msg[] INIT(= N_("--No lines in buffer--"));
 
 // When ":global" is used to number of substitutions and changed lines is
 // accumulated until it's finished.
diff --git a/src/nvim/hashtab.c b/src/nvim/hashtab.c
index f805d99d4b..851e70caca 100644
--- a/src/nvim/hashtab.c
+++ b/src/nvim/hashtab.c
@@ -88,7 +88,7 @@ void hash_clear_all(hashtab_T *ht, unsigned int off)
 ///                  is changed in any way.
 hashitem_T *hash_find(const hashtab_T *const ht, const char *const key)
 {
-  return hash_lookup(ht, key, strlen(key), hash_hash((char_u *)key));
+  return hash_lookup(ht, key, strlen(key), hash_hash(key));
 }
 
 /// Like hash_find, but key is not NUL-terminated
@@ -204,13 +204,13 @@ void hash_debug_results(void)
 ///         FAIL if key already present
 int hash_add(hashtab_T *ht, char *key)
 {
-  hash_T hash = hash_hash((char_u *)key);
+  hash_T hash = hash_hash(key);
   hashitem_T *hi = hash_lookup(ht, key, strlen(key), hash);
   if (!HASHITEM_EMPTY(hi)) {
     internal_error("hash_add()");
     return FAIL;
   }
-  hash_add_item(ht, hi, (char_u *)key, hash);
+  hash_add_item(ht, hi, key, hash);
   return OK;
 }
 
@@ -221,14 +221,14 @@ int hash_add(hashtab_T *ht, char *key)
 /// @param key  Pointer to the key for the new item. The key has to be contained
 ///             in the new item (@see hashitem_T). Must not be NULL.
 /// @param hash The precomputed hash value for the key.
-void hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash)
+void hash_add_item(hashtab_T *ht, hashitem_T *hi, char *key, hash_T hash)
 {
   ht->ht_used++;
   ht->ht_changed++;
   if (hi->hi_key == NULL) {
     ht->ht_filled++;
   }
-  hi->hi_key = (char *)key;
+  hi->hi_key = key;
   hi->hi_hash = hash;
 
   // When the space gets low may resize the array.
@@ -406,9 +406,9 @@ static void hash_may_resize(hashtab_T *ht, size_t minitems)
 /// run a script that uses hashtables a lot. Vim will then print statistics
 /// when exiting. Try that with the current hash algorithm and yours. The
 /// lower the percentage the better.
-hash_T hash_hash(const char_u *key)
+hash_T hash_hash(const char *key)
 {
-  hash_T hash = *key;
+  hash_T hash = (uint8_t)(*key);
 
   if (hash == 0) {
     return (hash_T)0;
@@ -416,7 +416,7 @@ hash_T hash_hash(const char_u *key)
 
   // A simplistic algorithm that appears to do very well.
   // Suggested by George Reilly.
-  const uint8_t *p = key + 1;
+  const uint8_t *p = (uint8_t *)key + 1;
   while (*p != NUL) {
     HASH_CYCLE_BODY(hash, p);
   }
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index ed4005d139..2d1b5efb0a 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -388,7 +388,7 @@ int get_indent_buf(buf_T *buf, linenr_T lnum)
 /// Count the size (in window cells) of the indent in line "ptr", with
 /// 'tabstop' at "ts".
 /// If @param list is true, count only screen size for tabs.
-int get_indent_str(const char_u *ptr, int ts, bool list)
+int get_indent_str(const char *ptr, int ts, bool list)
   FUNC_ATTR_NONNULL_ALL
 {
   int count = 0;
@@ -402,7 +402,7 @@ int get_indent_str(const char_u *ptr, int ts, bool list)
       } else {
         // In list mode, when tab is not set, count screen char width
         // for Tab, displays: ^I
-        count += ptr2cells((char *)ptr);
+        count += ptr2cells(ptr);
       }
     } else if (*ptr == ' ') {
       // Count a space for one.
@@ -805,7 +805,7 @@ int get_breakindent_win(win_T *wp, char *line)
 {
   static int prev_indent = 0;  // Cached indent value.
   static long prev_ts = 0L;  // Cached tabstop value.
-  static const char_u *prev_line = NULL;  // cached pointer to line.
+  static const char *prev_line = NULL;  // cached pointer to line.
   static varnumber_T prev_tick = 0;  // Changedtick of cached value.
   static long *prev_vts = NULL;  // Cached vartabs values.
   static int prev_list = 0;  // cached list value
@@ -822,12 +822,12 @@ int get_breakindent_win(win_T *wp, char *line)
   // - 'tabstop' changed
   // - 'briopt_list changed' changed or
   // - 'formatlistpattern' changed
-  if (prev_line != (char_u *)line || prev_ts != wp->w_buffer->b_p_ts
+  if (prev_line != line || prev_ts != wp->w_buffer->b_p_ts
       || prev_tick != buf_get_changedtick(wp->w_buffer)
       || prev_listopt != wp->w_briopt_list
       || (prev_flp == NULL || (strcmp(prev_flp, get_flp_value(wp->w_buffer)) != 0))
       || prev_vts != wp->w_buffer->b_p_vts_array) {
-    prev_line = (char_u *)line;
+    prev_line = line;
     prev_ts = wp->w_buffer->b_p_ts;
     prev_tick = buf_get_changedtick(wp->w_buffer);
     prev_vts = wp->w_buffer->b_p_vts_array;
@@ -881,7 +881,7 @@ int get_breakindent_win(win_T *wp, char *line)
 
   // indent minus the length of the showbreak string
   if (wp->w_briopt_sbr) {
-    bri -= vim_strsize((char *)get_showbreak_value(wp));
+    bri -= vim_strsize(get_showbreak_value(wp));
   }
 
   // never indent past left window margin
@@ -903,10 +903,10 @@ int get_breakindent_win(win_T *wp, char *line)
 // the line.
 int inindent(int extra)
 {
-  char_u *ptr;
+  char *ptr;
   colnr_T col;
 
-  for (col = 0, ptr = (char_u *)get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
+  for (col = 0, ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
     ptr++;
   }
 
@@ -1189,7 +1189,7 @@ int get_lisp_indent(void)
 {
   pos_T *pos, realpos, paren;
   int amount;
-  char_u *that;
+  char *that;
   colnr_T col;
   colnr_T firsttry;
   int parencount;
@@ -1224,7 +1224,7 @@ int get_lisp_indent(void)
         continue;
       }
 
-      for (that = (char_u *)get_cursor_line_ptr(); *that != NUL; that++) {
+      for (that = get_cursor_line_ptr(); *that != NUL; that++) {
         if (*that == ';') {
           while (*(that + 1) != NUL) {
             that++;
@@ -1274,20 +1274,20 @@ int get_lisp_indent(void)
       curwin->w_cursor.col = pos->col;
       col = pos->col;
 
-      that = (char_u *)get_cursor_line_ptr();
+      that = get_cursor_line_ptr();
 
       if (vi_lisp && (get_indent() == 0)) {
         amount = 2;
       } else {
-        char_u *line = that;
+        char *line = that;
         chartabsize_T cts;
-        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, (char *)line, (char *)line);
+        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
         while (*cts.cts_ptr != NUL && col > 0) {
           cts.cts_vcol += lbr_chartabsize_adv(&cts);
           col--;
         }
         amount = cts.cts_vcol;
-        that = (char_u *)cts.cts_ptr;
+        that = cts.cts_ptr;
         clear_chartabsize_arg(&cts);
 
         // Some keywords require "body" indenting rules (the
@@ -1295,7 +1295,7 @@ int get_lisp_indent(void)
         // (let ((a 1))    instead    (let ((a 1))
         //   (...))       of       (...))
         if (!vi_lisp && ((*that == '(') || (*that == '['))
-            && lisp_match((char *)that + 1)) {
+            && lisp_match(that + 1)) {
           amount += 2;
         } else {
           if (*that != NUL) {
@@ -1305,12 +1305,12 @@ int get_lisp_indent(void)
           firsttry = amount;
 
           init_chartabsize_arg(&cts, curwin, (colnr_T)(that - line),
-                               amount, (char *)line, (char *)that);
+                               amount, line, that);
           while (ascii_iswhite(*cts.cts_ptr)) {
             cts.cts_vcol += lbr_chartabsize(&cts);
             cts.cts_ptr++;
           }
-          that = (char_u *)cts.cts_ptr;
+          that = cts.cts_ptr;
           amount = cts.cts_vcol;
           clear_chartabsize_arg(&cts);
 
@@ -1326,9 +1326,10 @@ int get_lisp_indent(void)
             quotecount = 0;
 
             init_chartabsize_arg(&cts, curwin,
-                                 (colnr_T)(that - line), amount, (char *)line, (char *)that);
+                                 (colnr_T)(that - line), amount, line, that);
             if (vi_lisp || ((*that != '"') && (*that != '\'')
-                            && (*that != '#') && ((*that < '0') || (*that > '9')))) {
+                            && (*that != '#')
+                            && (((uint8_t)(*that) < '0') || ((uint8_t)(*that) > '9')))) {
               while (*cts.cts_ptr
                      && (!ascii_iswhite(*cts.cts_ptr) || quotecount || parencount)
                      && (!((*cts.cts_ptr == '(' || *cts.cts_ptr == '[')
@@ -1354,7 +1355,7 @@ int get_lisp_indent(void)
               cts.cts_vcol += lbr_chartabsize(&cts);
               cts.cts_ptr++;
             }
-            that = (char_u *)cts.cts_ptr;
+            that = cts.cts_ptr;
             amount = cts.cts_vcol;
             clear_chartabsize_arg(&cts);
 
@@ -1377,7 +1378,7 @@ static int lisp_match(char *p)
 {
   char buf[LSIZE];
   int len;
-  char *word = (char *)(*curbuf->b_p_lw != NUL ? (char_u *)curbuf->b_p_lw : p_lispwords);
+  char *word = *curbuf->b_p_lw != NUL ? curbuf->b_p_lw : p_lispwords;
 
   while (*word != NUL) {
     (void)copy_option_part(&word, buf, LSIZE, ",");
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 38fb7a2873..a8af8ec966 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2997,7 +2997,7 @@ static void get_next_filename_completion(void)
 #ifdef BACKSLASH_IN_FILENAME
   if (curbuf->b_p_csl[0] != NUL) {
     for (int i = 0; i < num_matches; i++) {
-      char_u *ptr = matches[i];
+      char *ptr = matches[i];
       while (*ptr != NUL) {
         if (curbuf->b_p_csl[0] == 's' && *ptr == '\\') {
           *ptr = '/';
diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index a4228fcc7e..552dec6bf8 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -541,7 +541,7 @@ char_u *get_special_key_name(int c, int modifiers)
       } else if (vim_isprintc(c)) {
         string[idx++] = (char_u)c;
       } else {
-        s = transchar(c);
+        s = (char_u *)transchar(c);
         while (*s) {
           string[idx++] = *s++;
         }
@@ -572,7 +572,7 @@ char_u *get_special_key_name(int c, int modifiers)
 /// @param[out]  did_simplify  found <C-H>, etc.
 ///
 /// @return Number of characters added to dst, zero for no match.
-unsigned int trans_special(const char **const srcp, const size_t src_len, char_u *const dst,
+unsigned int trans_special(const char **const srcp, const size_t src_len, char *const dst,
                            const int flags, const bool escape_ks, bool *const did_simplify)
   FUNC_ATTR_NONNULL_ARG(1, 3) FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -582,7 +582,7 @@ unsigned int trans_special(const char **const srcp, const size_t src_len, char_u
     return 0;
   }
 
-  return special_to_buf(key, modifiers, escape_ks, dst);
+  return special_to_buf(key, modifiers, escape_ks, (char_u *)dst);
 }
 
 /// Put the character sequence for "key" with "modifiers" into "dst" and return
@@ -944,7 +944,7 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
         }
       }
 
-      slen = trans_special(&src, (size_t)(end - src) + 1, (char_u *)result + dlen,
+      slen = trans_special(&src, (size_t)(end - src) + 1, result + dlen,
                            FSK_KEYCODE | ((flags & REPTERM_NO_SIMPLIFY) ? 0 : FSK_SIMPLIFY),
                            true, did_simplify);
       if (slen) {
@@ -1059,8 +1059,8 @@ char *vim_strsave_escape_ks(char *p)
   // Need a buffer to hold up to three times as much.  Four in case of an
   // illegal utf-8 byte:
   // 0xc0 -> 0xc3 - 0x80 -> 0xc3 K_SPECIAL KS_SPECIAL KE_FILLER
-  char_u *res = xmalloc(strlen(p) * 4 + 1);
-  char_u *d = res;
+  char *res = xmalloc(strlen(p) * 4 + 1);
+  char_u *d = (char_u *)res;
   for (char_u *s = (char_u *)p; *s != NUL;) {
     if (s[0] == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
       // Copy special key unmodified.
@@ -1076,7 +1076,7 @@ char *vim_strsave_escape_ks(char *p)
   }
   *d = NUL;
 
-  return (char *)res;
+  return res;
 }
 
 /// Remove escaping from K_SPECIAL characters.  Reverse of
diff --git a/src/nvim/locale.c b/src/nvim/locale.c
index 6322271073..c3cfd3bedb 100644
--- a/src/nvim/locale.c
+++ b/src/nvim/locale.c
@@ -294,7 +294,7 @@ static char **find_locales(void)
   if (locale_a == NULL) {
     return NULL;
   }
-  ga_init(&locales_ga, sizeof(char_u *), 20);
+  ga_init(&locales_ga, sizeof(char *), 20);
 
   // Transform locale_a string where each locale is separated by "\n"
   // into an array of locale strings.
@@ -308,7 +308,7 @@ static char **find_locales(void)
   xfree(locale_a);
   // Guarantee that .ga_data is NULL terminated
   ga_grow(&locales_ga, 1);
-  ((char_u **)locales_ga.ga_data)[locales_ga.ga_len] = NULL;
+  ((char **)locales_ga.ga_data)[locales_ga.ga_len] = NULL;
   return locales_ga.ga_data;
 }
 # endif
diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index 3c129fe7ce..6160b84485 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -391,7 +391,7 @@ nlua_pop_typval_table_processing_end:
     case LUA_TFUNCTION: {
       LuaRef func = nlua_ref_global(lstate, -1);
 
-      char *name = (char *)register_luafunc(func);
+      char *name = register_luafunc(func);
 
       cur.tv->v_type = VAR_FUNC;
       cur.tv->vval.v_string = xstrdup(name);
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index f23310304f..7006c1dc4e 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1950,7 +1950,7 @@ char_u *nlua_register_table_as_callable(const typval_T *const arg)
 
   LuaRef func = nlua_ref_global(lstate, -1);
 
-  char_u *name = register_luafunc(func);
+  char_u *name = (char_u *)register_luafunc(func);
 
   lua_pop(lstate, 1);  // []
   assert(top == lua_gettop(lstate));
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index dac96790d7..8b74418753 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -40,17 +40,17 @@
 # include "lua/stdlib.c.generated.h"
 #endif
 
-static int regex_match(lua_State *lstate, regprog_T **prog, char_u *str)
+static int regex_match(lua_State *lstate, regprog_T **prog, char *str)
 {
   regmatch_T rm;
   rm.regprog = *prog;
   rm.rm_ic = false;
-  bool match = vim_regexec(&rm, (char *)str, 0);
+  bool match = vim_regexec(&rm, str, 0);
   *prog = rm.regprog;
 
   if (match) {
-    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - (char *)str));
-    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - (char *)str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - str));
     return 2;
   }
   return 0;
@@ -60,7 +60,7 @@ static int regex_match_str(lua_State *lstate)
 {
   regprog_T **prog = regex_check(lstate);
   const char *str = luaL_checkstring(lstate, 2);
-  int nret = regex_match(lstate, prog, (char_u *)str);
+  int nret = regex_match(lstate, prog, (char *)str);
 
   if (!*prog) {
     return luaL_error(lstate, "regex: internal error");
@@ -116,7 +116,7 @@ static int regex_match_line(lua_State *lstate)
     line[end] = NUL;
   }
 
-  int nret = regex_match(lstate, prog, (char_u *)line + start);
+  int nret = regex_match(lstate, prog, line + start);
 
   if (end >= 0) {
     line[end] = save;
@@ -198,7 +198,7 @@ static int nlua_str_utf_pos(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   size_t idx = 1;
   size_t clen;
   for (size_t i = 0; i < s1_len && s1[i] != NUL; i += clen) {
-    clen = (size_t)utf_ptr2len_len((const char_u *)(s1) + i, (int)(s1_len - i));
+    clen = (size_t)utf_ptr2len_len(s1 + i, (int)(s1_len - i));
     lua_pushinteger(lstate, (long)i + 1);
     lua_rawseti(lstate, -2, (int)idx);
     idx++;
@@ -266,8 +266,7 @@ int nlua_str_byteindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
     use_utf16 = lua_toboolean(lstate, 3);
   }
 
-  ssize_t byteidx = mb_utf_index_to_bytes((const char_u *)s1, s1_len,
-                                          (size_t)idx, use_utf16);
+  ssize_t byteidx = mb_utf_index_to_bytes(s1, s1_len, (size_t)idx, use_utf16);
   if (byteidx == -1) {
     return luaL_error(lstate, "index out of range");
   }
@@ -503,14 +502,14 @@ static int nlua_iconv(lua_State *lstate)
   size_t str_len = 0;
   const char *str = lua_tolstring(lstate, 1, &str_len);
 
-  char_u *from = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 2, NULL)));
-  char_u *to   = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 3, NULL)));
+  char *from = enc_canonize(enc_skip((char *)lua_tolstring(lstate, 2, NULL)));
+  char *to   = enc_canonize(enc_skip((char *)lua_tolstring(lstate, 3, NULL)));
 
   vimconv_T vimconv;
   vimconv.vc_type = CONV_NONE;
-  convert_setup_ext(&vimconv, (char *)from, false, (char *)to, false);
+  convert_setup_ext(&vimconv, from, false, to, false);
 
-  char_u *ret = (char_u *)string_convert(&vimconv, (char *)str, &str_len);
+  char *ret = string_convert(&vimconv, (char *)str, &str_len);
 
   convert_setup(&vimconv, NULL, NULL);
 
@@ -520,7 +519,7 @@ static int nlua_iconv(lua_State *lstate)
   if (ret == NULL) {
     lua_pushnil(lstate);
   } else {
-    lua_pushlstring(lstate, (char *)ret, str_len);
+    lua_pushlstring(lstate, ret, str_len);
     xfree(ret);
   }
 
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 29c6bb6723..2a943db5d5 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -1851,9 +1851,9 @@ int makemap(FILE *fd, buf_T *buf)
           }
 
           if (putc(' ', fd) < 0
-              || put_escstr(fd, (char_u *)mp->m_keys, 0) == FAIL
+              || put_escstr(fd, mp->m_keys, 0) == FAIL
               || putc(' ', fd) < 0
-              || put_escstr(fd, (char_u *)mp->m_str, 1) == FAIL
+              || put_escstr(fd, mp->m_str, 1) == FAIL
               || put_eol(fd) < 0) {
             return FAIL;
           }
@@ -1879,9 +1879,9 @@ int makemap(FILE *fd, buf_T *buf)
 // "what": 0 for :map lhs, 1 for :map rhs, 2 for :set
 //
 // return FAIL for failure, OK otherwise
-int put_escstr(FILE *fd, char_u *strstart, int what)
+int put_escstr(FILE *fd, char *strstart, int what)
 {
-  char_u *str = strstart;
+  char_u *str = (char_u *)strstart;
   int c;
 
   // :map xx <Nop>
@@ -1958,7 +1958,7 @@ int put_escstr(FILE *fd, char_u *strstart, int what)
       }
     } else if (c < ' ' || c > '~' || c == '|'
                || (what == 0 && c == ' ')
-               || (what == 1 && str == strstart && c == ' ')
+               || (what == 1 && str == (char_u *)strstart && c == ' ')
                || (what != 2 && c == '<')) {
       if (putc(Ctrl_V, fd) < 0) {
         return FAIL;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 68e8a3269b..eafbf0b17a 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -540,7 +540,7 @@ int utf_ptr2cells_len(const char *p, int size)
 
   // Need to convert to a wide character.
   if (size > 0 && (uint8_t)(*p) >= 0x80) {
-    if (utf_ptr2len_len((char_u *)p, size) < utf8len_tab[(uint8_t)(*p)]) {
+    if (utf_ptr2len_len(p, size) < utf8len_tab[(uint8_t)(*p)]) {
       return 1;        // truncated
     }
     c = utf_ptr2char((char *)p);
@@ -584,9 +584,9 @@ size_t mb_string2cells_len(const char *str, size_t size)
 {
   size_t clen = 0;
 
-  for (const char_u *p = (char_u *)str; *p != NUL && p < (char_u *)str + size;
-       p += utfc_ptr2len_len((char *)p, (int)size + (int)(p - (char_u *)str))) {
-    clen += (size_t)utf_ptr2cells((char *)p);
+  for (const char *p = str; *p != NUL && p < str + size;
+       p += utfc_ptr2len_len(p, (int)size + (int)(p - str))) {
+    clen += (size_t)utf_ptr2cells(p);
   }
 
   return clen;
@@ -785,7 +785,7 @@ int utfc_ptr2char_len(const char *p, int *pcc, int maxlen)
 
   int i = 0;
 
-  int len = utf_ptr2len_len((char_u *)p, maxlen);
+  int len = utf_ptr2len_len(p, maxlen);
   // Is it safe to use utf_ptr2char()?
   bool safe = len > 1 && len <= maxlen;
   int c = safe ? utf_ptr2char(p) : (uint8_t)(*p);
@@ -793,7 +793,7 @@ int utfc_ptr2char_len(const char *p, int *pcc, int maxlen)
   // Only accept a composing char when the first char isn't illegal.
   if ((safe || c < 0x80) && len < maxlen && (uint8_t)p[len] >= 0x80) {
     for (; i < MAX_MCO; i++) {
-      int len_cc = utf_ptr2len_len((char_u *)p + len, maxlen - len);
+      int len_cc = utf_ptr2len_len(p + len, maxlen - len);
       safe = len_cc > 1 && len_cc <= maxlen - len;
       if (!safe || (pcc[i] = utf_ptr2char(p + len)) < 0x80
           || !(i == 0 ? utf_composinglike(p, p + len) : utf_iscomposing(pcc[i]))) {
@@ -848,13 +848,13 @@ int utf_byte2len(int b)
 // Returns 1 for an illegal byte sequence (also in incomplete byte seq.).
 // Returns number > "size" for an incomplete byte sequence.
 // Never returns zero.
-int utf_ptr2len_len(const char_u *p, int size)
+int utf_ptr2len_len(const char *p, int size)
 {
   int len;
   int i;
   int m;
 
-  len = utf8len_tab[*p];
+  len = utf8len_tab[(uint8_t)(*p)];
   if (len == 1) {
     return 1;           // NUL, ascii or illegal lead byte
   }
@@ -925,7 +925,7 @@ int utfc_ptr2len_len(const char *p, int size)
   }
 
   // Skip over first UTF-8 char, stopping at a NUL byte.
-  len = utf_ptr2len_len((char_u *)p, size);
+  len = utf_ptr2len_len(p, size);
 
   // Check for illegal byte and incomplete byte sequence.
   if ((len == 1 && (uint8_t)p[0] >= 0x80) || len > size) {
@@ -944,7 +944,7 @@ int utfc_ptr2len_len(const char *p, int size)
 
     // Next character length should not go beyond size to ensure that
     // utf_composinglike(...) does not read beyond size.
-    len_next_char = utf_ptr2len_len((char_u *)p + len, size - len);
+    len_next_char = utf_ptr2len_len(p + len, size - len);
     if (len_next_char > size - len) {
       break;
     }
@@ -1462,7 +1462,7 @@ void mb_utflen(const char *s, size_t len, size_t *codepoints, size_t *codeunits)
   size_t count = 0, extra = 0;
   size_t clen;
   for (size_t i = 0; i < len; i += clen) {
-    clen = (size_t)utf_ptr2len_len((char_u *)s + i, (int)(len - i));
+    clen = (size_t)utf_ptr2len_len(s + i, (int)(len - i));
     // NB: gets the byte value of invalid sequence bytes.
     // we only care whether the char fits in the BMP or not
     int c = (clen > 1) ? utf_ptr2char(s + i) : (uint8_t)s[i];
@@ -1475,7 +1475,7 @@ void mb_utflen(const char *s, size_t len, size_t *codepoints, size_t *codeunits)
   *codeunits += count + extra;
 }
 
-ssize_t mb_utf_index_to_bytes(const char_u *s, size_t len, size_t index, bool use_utf16_units)
+ssize_t mb_utf_index_to_bytes(const char *s, size_t len, size_t index, bool use_utf16_units)
   FUNC_ATTR_NONNULL_ALL
 {
   size_t count = 0;
@@ -1487,7 +1487,7 @@ ssize_t mb_utf_index_to_bytes(const char_u *s, size_t len, size_t index, bool us
     clen = (size_t)utf_ptr2len_len(s + i, (int)(len - i));
     // NB: gets the byte value of invalid sequence bytes.
     // we only care whether the char fits in the BMP or not
-    int c = (clen > 1) ? utf_ptr2char((char *)s + i) : s[i];
+    int c = (clen > 1) ? utf_ptr2char(s + i) : (uint8_t)s[i];
     count++;
     if (use_utf16_units && c > 0xFFFF) {
       count++;
@@ -1787,7 +1787,7 @@ void mb_copy_char(const char **const fp, char **const tp)
 /// Return the offset from "p_in" to the first byte of a character.  When "p_in" is
 /// at the start of a character 0 is returned, otherwise the offset to the next
 /// character.  Can start anywhere in a stream of bytes.
-int mb_off_next(const char_u *base, const char *p_in)
+int mb_off_next(const char *base, const char *p_in)
 {
   const uint8_t *p = (uint8_t *)p_in;
   int i;
@@ -1801,7 +1801,7 @@ int mb_off_next(const char_u *base, const char *p_in)
   for (i = 0; (p[i] & 0xc0) == 0x80; i++) {}
   if (i > 0) {
     // Check for illegal sequence.
-    for (j = 0; p - j > base; j++) {
+    for (j = 0; p - j > (uint8_t *)base; j++) {
       if ((p[-j] & 0xc0) != 0x80) {
         break;
       }
@@ -2265,7 +2265,7 @@ enc_locale_copy_enc:
 // versions).
 // Returns (void *)-1 if failed.
 // (should return iconv_t, but that causes problems with prototypes).
-void *my_iconv_open(char_u *to, char_u *from)
+void *my_iconv_open(char *to, char *from)
 {
   iconv_t fd;
 # define ICONV_TESTLEN 400
@@ -2277,7 +2277,7 @@ void *my_iconv_open(char_u *to, char_u *from)
   if (iconv_working == kBroken) {
     return (void *)-1;          // detected a broken iconv() previously
   }
-  fd = iconv_open(enc_skip((char *)to), enc_skip((char *)from));
+  fd = iconv_open(enc_skip(to), enc_skip(from));
 
   if (fd != (iconv_t)-1 && iconv_working == kUnknown) {
     // Do a dummy iconv() call to check if it actually works.  There is a
@@ -2452,8 +2452,8 @@ int convert_setup_ext(vimconv_T *vcp, char *from, bool from_unicode_is_utf8, cha
 #ifdef HAVE_ICONV
   else {  // NOLINT(readability/braces)
     // Use iconv() for conversion.
-    vcp->vc_fd = (iconv_t)my_iconv_open(to_is_utf8 ? (char_u *)"utf-8" : (char_u *)to,
-                                        from_is_utf8 ? (char_u *)"utf-8" : (char_u *)from);
+    vcp->vc_fd = (iconv_t)my_iconv_open(to_is_utf8 ? "utf-8" : to,
+                                        from_is_utf8 ? "utf-8" : from);
     if (vcp->vc_fd != (iconv_t)-1) {
       vcp->vc_type = CONV_ICONV;
       vcp->vc_factor = 4;       // could be longer too...
@@ -2553,7 +2553,7 @@ char_u *string_convert_ext(const vimconv_T *const vcp, char_u *ptr, size_t *lenp
     retval = xmalloc(len + 1);
     d = retval;
     for (size_t i = 0; i < len; i++) {
-      l = utf_ptr2len_len(ptr + i, (int)(len - i));
+      l = utf_ptr2len_len((char *)ptr + i, (int)(len - i));
       if (l == 0) {
         *d++ = NUL;
       } else if (l == 1) {
diff --git a/src/nvim/move.c b/src/nvim/move.c
index ee9edb3dc4..3af26b910e 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -760,7 +760,7 @@ void curs_columns(win_T *wp, int may_scroll)
       // When cursor wraps to first char of next line in Insert
       // mode, the 'showbreak' string isn't shown, backup to first
       // column
-      char *const sbr = (char *)get_showbreak_value(wp);
+      char *const sbr = get_showbreak_value(wp);
       if (*sbr && *get_cursor_pos_ptr() == NUL
           && wp->w_wcol == vim_strsize(sbr)) {
         wp->w_wcol = 0;
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index ad2bcbc790..798ea4f990 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -1526,8 +1526,7 @@ void restore_visual_mode(void)
 /// @param dir    the direction of searching, is either FORWARD or BACKWARD
 /// @param *colp  is in/decremented if "ptr[-dir]" should also be included.
 /// @param bnp    points to a counter for square brackets.
-static bool find_is_eval_item(const char_u *const ptr, int *const colp, int *const bnp,
-                              const int dir)
+static bool find_is_eval_item(const char *const ptr, int *const colp, int *const bnp, const int dir)
 {
   // Accept everything inside [].
   if ((*ptr == ']' && dir == BACKWARD) || (*ptr == '[' && dir == FORWARD)) {
@@ -1635,7 +1634,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
               || (find_type & FIND_IDENT))
           && (!(find_type & FIND_EVAL)
               || prevcol == 0
-              || !find_is_eval_item((char_u *)ptr + prevcol, &prevcol, &bn, BACKWARD))) {
+              || !find_is_eval_item(ptr + prevcol, &prevcol, &bn, BACKWARD))) {
         break;
       }
       col = prevcol;
@@ -1678,7 +1677,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
               : mb_get_class(ptr + col) != 0)
              || ((find_type & FIND_EVAL)
                  && col <= (int)startcol
-                 && find_is_eval_item((char_u *)ptr + col, &col, &bn, FORWARD)))) {
+                 && find_is_eval_item(ptr + col, &col, &bn, FORWARD)))) {
     col += utfc_ptr2len(ptr + col);
   }
 
@@ -1927,7 +1926,7 @@ bool add_to_showcmd(int c)
     }
   }
 
-  char *p = (char *)transchar(c);
+  char *p = transchar(c);
   if (*p == ' ') {
     STRCPY(p, "<20>");
   }
@@ -2236,7 +2235,7 @@ static void nv_gd(oparg_T *oap, int nchar, int thisblock)
   size_t len;
   char *ptr;
   if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0
-      || !find_decl((char_u *)ptr, len, nchar == 'd', thisblock, SEARCH_START)) {
+      || !find_decl(ptr, len, nchar == 'd', thisblock, SEARCH_START)) {
     clearopbeep(oap);
     return;
   }
@@ -2252,7 +2251,7 @@ static void nv_gd(oparg_T *oap, int nchar, int thisblock)
 
 /// @return true if line[offset] is not inside a C-style comment or string,
 ///         false otherwise.
-static bool is_ident(const char_u *line, int offset)
+static bool is_ident(const char *line, int offset)
 {
   bool incomment = false;
   int instring = 0;
@@ -2260,11 +2259,11 @@ static bool is_ident(const char_u *line, int offset)
 
   for (int i = 0; i < offset && line[i] != NUL; i++) {
     if (instring != 0) {
-      if (prev != '\\' && line[i] == instring) {
+      if (prev != '\\' && (uint8_t)line[i] == instring) {
         instring = 0;
       }
     } else if ((line[i] == '"' || line[i] == '\'') && !incomment) {
-      instring = line[i];
+      instring = (uint8_t)line[i];
     } else {
       if (incomment) {
         if (prev == '*' && line[i] == '/') {
@@ -2277,7 +2276,7 @@ static bool is_ident(const char_u *line, int offset)
       }
     }
 
-    prev = line[i];
+    prev = (uint8_t)line[i];
   }
 
   return incomment == false && instring == 0;
@@ -2291,7 +2290,7 @@ static bool is_ident(const char_u *line, int offset)
 /// @param flags_arg  flags passed to searchit()
 ///
 /// @return           fail when not found.
-bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_arg)
+bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_arg)
 {
   char *pat;
   pos_T old_pos;
@@ -2309,7 +2308,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
   // Put "\V" before the pattern to avoid that the special meaning of "."
   // and "~" causes trouble.
   assert(len <= INT_MAX);
-  sprintf(pat, vim_iswordp((char *)ptr) ? "\\V\\<%.*s\\>" : "\\V%.*s",  // NOLINT(runtime/printf)
+  sprintf(pat, vim_iswordp(ptr) ? "\\V\\<%.*s\\>" : "\\V%.*s",  // NOLINT(runtime/printf)
           (int)len, ptr);
   old_pos = curwin->w_cursor;
   save_p_ws = p_ws;
@@ -2370,7 +2369,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
       curwin->w_cursor.col = 0;
       continue;
     }
-    bool valid = is_ident((char_u *)get_cursor_line_ptr(), curwin->w_cursor.col);
+    bool valid = is_ident(get_cursor_line_ptr(), curwin->w_cursor.col);
 
     // If the current position is not a valid identifier and a previous match is
     // present, favor that one instead.
@@ -2551,7 +2550,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
     validate_virtcol();
     colnr_T virtcol = curwin->w_virtcol;
     if (virtcol > (colnr_T)width1 && *get_showbreak_value(curwin) != NUL) {
-      virtcol -= vim_strsize((char *)get_showbreak_value(curwin));
+      virtcol -= vim_strsize(get_showbreak_value(curwin));
     }
 
     int c = utf_ptr2char(get_cursor_pos_ptr());
@@ -3929,7 +3928,7 @@ static void nv_gotofile(cmdarg_T *cap)
     return;
   }
 
-  ptr = (char *)grab_file_name(cap->count1, &lnum);
+  ptr = grab_file_name(cap->count1, &lnum);
 
   if (ptr != NULL) {
     // do autowrite if necessary
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index dfaf12b357..c87aa596c3 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -1363,9 +1363,8 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
     if (!errmsg) {
       return false;
     }
-    *argp
-      = (char *)file_name_at_cursor(FNAME_MESS | FNAME_HYP | (regname == Ctrl_P ? FNAME_EXP : 0),
-                                    1L, NULL);
+    *argp = file_name_at_cursor(FNAME_MESS | FNAME_HYP | (regname == Ctrl_P ? FNAME_EXP : 0),
+                                1L, NULL);
     *allocated = true;
     return true;
 
@@ -3148,7 +3147,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
 
   if (y_size == 0 || y_array == NULL) {
     semsg(_("E353: Nothing in register %s"),
-          regname == 0 ? (char_u *)"\"" : transchar(regname));
+          regname == 0 ? "\"" : transchar(regname));
     goto end;
   }
 
@@ -5178,7 +5177,7 @@ static void str_to_reg(yankreg_T *y_ptr, MotionType yank_type, const char *str,
 
   // Count the number of lines within the string
   if (str_list) {
-    for (char_u **ss = (char_u **)str; *ss != NULL; ss++) {
+    for (char **ss = (char **)str; *ss != NULL; ss++) {
       newlines++;
     }
   } else {
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 227001d556..2bd3dcfe2d 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -1390,7 +1390,7 @@ int do_set(char *arg, int opt_flags)
                            || *arg == '^'
                            || (*arg != NUL && (!arg[1] || ascii_iswhite(arg[1]))
                                && !ascii_isdigit(*arg)))) {
-              value = string_to_key((char_u *)arg);
+              value = string_to_key(arg);
               if (value == 0 && (long *)varp != &p_wcm) {
                 errmsg = e_invarg;
                 goto skip;
@@ -1520,15 +1520,15 @@ void did_set_option(int opt_idx, int opt_flags, int new_value, int value_checked
 
 /// Convert a key name or string into a key value.
 /// Used for 'wildchar' and 'cedit' options.
-int string_to_key(char_u *arg)
+int string_to_key(char *arg)
 {
   if (*arg == '<') {
-    return find_key_option((char *)arg + 1, true);
+    return find_key_option(arg + 1, true);
   }
   if (*arg == '^') {
-    return CTRL_CHR(arg[1]);
+    return CTRL_CHR((uint8_t)arg[1]);
   }
-  return *arg;
+  return (uint8_t)(*arg);
 }
 
 // When changing 'title', 'titlestring', 'icon' or 'iconstring', call
@@ -1601,9 +1601,9 @@ void set_options_bin(int oldval, int newval, int opt_flags)
 /// number, return -1.
 int get_shada_parameter(int type)
 {
-  char_u *p = find_shada_parameter(type);
+  char *p = find_shada_parameter(type);
   if (p != NULL && ascii_isdigit(*p)) {
-    return atoi((char *)p);
+    return atoi(p);
   }
   return -1;
 }
@@ -1611,11 +1611,11 @@ int get_shada_parameter(int type)
 /// Find the parameter represented by the given character (eg ''', ':', '"', or
 /// '/') in the 'shada' option and return a pointer to the string after it.
 /// Return NULL if the parameter is not specified in the string.
-char_u *find_shada_parameter(int type)
+char *find_shada_parameter(int type)
 {
   for (char *p = p_shada; *p; p++) {
     if (*p == type) {
-      return (char_u *)p + 1;
+      return p + 1;
     }
     if (*p == 'n') {                // 'n' is always the last one
       break;
@@ -1773,7 +1773,7 @@ void redraw_titles(void)
 bool valid_name(const char *val, const char *allowed)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  for (const char_u *s = (char_u *)val; *s != NUL; s++) {
+  for (const char *s = val; *s != NUL; s++) {
     if (!ASCII_ISALNUM(*s)
         && vim_strchr(allowed, (uint8_t)(*s)) == NULL) {
       return false;
@@ -3090,10 +3090,10 @@ bool is_string_option(const char *name)
 // Translate a string like "t_xx", "<t_xx>" or "<S-Tab>" to a key number.
 // When "has_lt" is true there is a '<' before "*arg_arg".
 // Returns 0 when the key is not recognized.
-int find_key_option_len(const char_u *arg_arg, size_t len, bool has_lt)
+int find_key_option_len(const char *arg_arg, size_t len, bool has_lt)
 {
   int key = 0;
-  const char *arg = (char *)arg_arg;
+  const char *arg = arg_arg;
 
   // Don't use get_special_key_code() for t_xx, we don't want it to call
   // add_termcap_entry().
@@ -3113,7 +3113,7 @@ int find_key_option_len(const char_u *arg_arg, size_t len, bool has_lt)
 
 static int find_key_option(const char *arg, bool has_lt)
 {
-  return find_key_option_len((char_u *)arg, strlen(arg), has_lt);
+  return find_key_option_len(arg, strlen(arg), has_lt);
 }
 
 /// if 'all' == 0: show changed options
@@ -3431,7 +3431,7 @@ int makefoldset(FILE *fd)
 
 static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_t flags)
 {
-  char_u *buf = NULL;
+  char *buf = NULL;
   char_u *part = NULL;
 
   if (fprintf(fd, "%s %s=", cmd, name) < 0) {
@@ -3444,7 +3444,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
     if (valuep == &p_pt) {
       char_u *s = (char_u *)(*valuep);
       while (*s != NUL) {
-        if (put_escstr(fd, (char_u *)str2special((const char **)&s, false, false), 2) == FAIL) {
+        if (put_escstr(fd, (char *)str2special((const char **)&s, false, false), 2) == FAIL) {
           return FAIL;
         }
       }
@@ -3453,7 +3453,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
 
       // replace home directory in the whole option value into "buf"
       buf = xmalloc(size);
-      home_replace(NULL, *valuep, (char *)buf, size, false);
+      home_replace(NULL, *valuep, buf, size, false);
 
       // If the option value is longer than MAXPATHL, we need to append
       // each comma separated part of the option separately, so that it
@@ -3466,7 +3466,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
         if (put_eol(fd) == FAIL) {
           goto fail;
         }
-        char *p = (char *)buf;
+        char *p = buf;
         while (*p != NUL) {
           // for each comma separated option part, append value to
           // the option, :set rtp+=value
@@ -3474,7 +3474,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
             goto fail;
           }
           (void)copy_option_part(&p, (char *)part, size, ",");
-          if (put_escstr(fd, part, 2) == FAIL || put_eol(fd) == FAIL) {
+          if (put_escstr(fd, (char *)part, 2) == FAIL || put_eol(fd) == FAIL) {
             goto fail;
           }
         }
@@ -3487,7 +3487,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
         return FAIL;
       }
       xfree(buf);
-    } else if (put_escstr(fd, (char_u *)(*valuep), 2) == FAIL) {
+    } else if (put_escstr(fd, *valuep, 2) == FAIL) {
       return FAIL;
     }
   }
@@ -4843,7 +4843,7 @@ void ExpandOldSetting(int *num_file, char ***file)
 
   // A backslash is required before some characters.  This is the reverse of
   // what happens in do_set().
-  char_u *buf = (char_u *)vim_strsave_escaped(var, (char *)escape_chars);
+  char_u *buf = (char_u *)vim_strsave_escaped(var, escape_chars);
 
 #ifdef BACKSLASH_IN_FILENAME
   // For MS-Windows et al. we don't double backslashes at the start and
@@ -4877,7 +4877,7 @@ static void option_value2string(vimoption_T *opp, int scope)
     if (wc_use_keyname((char_u *)varp, &wc)) {
       xstrlcpy(NameBuff, (char *)get_special_key_name((int)wc, 0), sizeof(NameBuff));
     } else if (wc != 0) {
-      xstrlcpy(NameBuff, (char *)transchar((int)wc), sizeof(NameBuff));
+      xstrlcpy(NameBuff, transchar((int)wc), sizeof(NameBuff));
     } else {
       snprintf(NameBuff,
                sizeof(NameBuff),
@@ -5260,16 +5260,16 @@ unsigned int get_ve_flags(void)
 ///
 /// @param win  If not NULL, the window to get the local option from; global
 ///             otherwise.
-char_u *get_showbreak_value(win_T *const win)
+char *get_showbreak_value(win_T *const win)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if (win->w_p_sbr == NULL || *win->w_p_sbr == NUL) {
-    return (char_u *)p_sbr;
+    return p_sbr;
   }
   if (strcmp(win->w_p_sbr, "NONE") == 0) {
-    return (char_u *)empty_option;
+    return empty_option;
   }
-  return (char_u *)win->w_p_sbr;
+  return win->w_p_sbr;
 }
 
 /// Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC.
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 6385d968dd..e33e57424b 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -578,7 +578,7 @@ EXTERN long p_lines;            // 'lines'
 EXTERN long p_linespace;        // 'linespace'
 EXTERN int p_lisp;              ///< 'lisp'
 EXTERN char *p_lop;             ///< 'lispoptions'
-EXTERN char_u *p_lispwords;     // 'lispwords'
+EXTERN char *p_lispwords;       // 'lispwords'
 EXTERN long p_ls;               // 'laststatus'
 EXTERN long p_stal;             // 'showtabline'
 EXTERN char *p_lcs;             // 'listchars'
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index ab58888482..efb1ff2ab6 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -206,7 +206,7 @@ static char *illegal_char(char *errbuf, size_t errbuflen, int c)
     return "";
   }
   vim_snprintf(errbuf, errbuflen, _("E539: Illegal character <%s>"),
-               (char *)transchar(c));
+               transchar(c));
   return errbuf;
 }
 
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index ae34a79365..7e4710a2f7 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -543,7 +543,7 @@ void free_homedir(void)
 /// @see {expand_env}
 char *expand_env_save(char *src)
 {
-  return (char *)expand_env_save_opt(src, false);
+  return expand_env_save_opt(src, false);
 }
 
 /// Similar to expand_env_save() but when "one" is `true` handle the string as
@@ -551,10 +551,10 @@ char *expand_env_save(char *src)
 /// @param src String containing environment variables to expand
 /// @param one Should treat as only one file name
 /// @see {expand_env}
-char_u *expand_env_save_opt(char *src, bool one)
+char *expand_env_save_opt(char *src, bool one)
 {
-  char_u *p = xmalloc(MAXPATHL);
-  expand_env_esc(src, (char *)p, MAXPATHL, false, one, NULL);
+  char *p = xmalloc(MAXPATHL);
+  expand_env_esc(src, p, MAXPATHL, false, one, NULL);
   return p;
 }
 
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index ce1b2d1cf5..302faa8140 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -330,11 +330,11 @@ static bool is_executable_ext(const char *name, char **abspath)
 
     const char *ext_end = ext;
     size_t ext_len =
-      copy_option_part(&ext_end, (char_u *)buf_end,
+      copy_option_part((char **)&ext_end, buf_end,
                        sizeof(os_buf) - (size_t)(buf_end - os_buf), ENV_SEPSTR);
     if (ext_len != 0) {
       bool in_pathext = nameext_len == ext_len
-                        && 0 == mb_strnicmp((char_u *)nameext, (char_u *)ext, ext_len);
+                        && 0 == mb_strnicmp(nameext, ext, ext_len);
 
       if (((in_pathext || is_unix_shell) && is_executable(name, abspath))
           || is_executable(os_buf, abspath)) {
@@ -791,14 +791,14 @@ int os_setperm(const char *const name, int perm)
 
 // Return a pointer to the ACL of file "fname" in allocated memory.
 // Return NULL if the ACL is not available for whatever reason.
-vim_acl_T os_get_acl(const char_u *fname)
+vim_acl_T os_get_acl(const char *fname)
 {
   vim_acl_T ret = NULL;
   return ret;
 }
 
 // Set the ACL of file "fname" to "acl" (unless it's NULL).
-void os_set_acl(const char_u *fname, vim_acl_T aclent)
+void os_set_acl(const char *fname, vim_acl_T aclent)
 {
   if (aclent == NULL) {
     return;
diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index 51cabfbcbf..759b3cf83c 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -254,7 +254,8 @@ size_t input_enqueue(String keys)
     uint8_t buf[19] = { 0 };
     // Do not simplify the keys here. Simplification will be done later.
     unsigned int new_size
-      = trans_special((const char **)&ptr, (size_t)(end - ptr), buf, FSK_KEYCODE, true, NULL);
+      = trans_special((const char **)&ptr, (size_t)(end - ptr), (char *)buf, FSK_KEYCODE, true,
+                      NULL);
 
     if (new_size) {
       new_size = handle_mouse_event(&ptr, buf, new_size);
diff --git a/src/nvim/os/stdpaths.c b/src/nvim/os/stdpaths.c
index a99a8d25ce..6b07b6ef70 100644
--- a/src/nvim/os/stdpaths.c
+++ b/src/nvim/os/stdpaths.c
@@ -121,7 +121,7 @@ char *get_xdg_home(const XDGVarType idx)
 #endif
 
 #ifdef BACKSLASH_IN_FILENAME
-    slash_adjust((char_u *)dir);
+    slash_adjust(dir);
 #endif
   }
   return dir;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index da3659b8b8..12087d52bd 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -1260,7 +1260,7 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
     } else {
       // First expand environment variables, "~/" and "~user/".
       if ((has_env_var(p) && !(flags & EW_NOTENV)) || *p == '~') {
-        p = (char *)expand_env_save_opt(p, true);
+        p = expand_env_save_opt(p, true);
         if (p == NULL) {
           p = pat[i];
         } else {
@@ -1414,9 +1414,9 @@ static int expand_backtick(garray_T *gap, char *pat, int flags)
 /// backslash twice.
 /// When 'shellslash' set do it the other way around.
 /// When the path looks like a URL leave it unmodified.
-void slash_adjust(char_u *p)
+void slash_adjust(char *p)
 {
-  if (path_with_url((const char *)p)) {
+  if (path_with_url(p)) {
     return;
   }
 
@@ -1429,8 +1429,8 @@ void slash_adjust(char_u *p)
   }
 
   while (*p) {
-    if (*p == (char_u)psepcN) {
-      *p = (char_u)psepc;
+    if (*p == psepcN) {
+      *p = psepc;
     }
     MB_PTR_ADV(p);
   }
@@ -1690,8 +1690,8 @@ char *find_file_name_in_path(char *ptr, size_t len, int options, long count, cha
   }
 
   if (options & FNAME_EXP) {
-    file_name = (char *)find_file_in_path(ptr, len, options & ~FNAME_MESS, true,
-                                          rel_fname);
+    file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS, true,
+                                  rel_fname);
 
     // If the file could not be found in a normal way, try applying
     // 'includeexpr' (unless done already).
@@ -1701,8 +1701,8 @@ char *find_file_name_in_path(char *ptr, size_t len, int options, long count, cha
       if (tofree != NULL) {
         ptr = tofree;
         len = strlen(ptr);
-        file_name = (char *)find_file_in_path(ptr, len, options & ~FNAME_MESS,
-                                              true, rel_fname);
+        file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS,
+                                      true, rel_fname);
       }
     }
     if (file_name == NULL && (options & FNAME_MESS)) {
@@ -1717,7 +1717,7 @@ char *find_file_name_in_path(char *ptr, size_t len, int options, long count, cha
     while (file_name != NULL && --count > 0) {
       xfree(file_name);
       file_name =
-        (char *)find_file_in_path(ptr, len, options, false, rel_fname);
+        find_file_in_path(ptr, len, options, false, rel_fname);
     }
   } else {
     file_name = xstrnsave(ptr, len);
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index 38ca91a6ac..6393c8dea5 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -440,7 +440,7 @@ int win_lbr_chartabsize(chartabsize_T *cts, int *headp)
   // Set *headp to the size of what we add.
   // Do not use 'showbreak' at the NUL after the text.
   added = 0;
-  char *const sbr = c == NUL ? empty_option : (char *)get_showbreak_value(wp);
+  char *const sbr = c == NUL ? empty_option : get_showbreak_value(wp);
   if ((*sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && vcol != 0) {
     colnr_T sbrlen = 0;
     int numberwidth = win_col_off(wp);
diff --git a/src/nvim/profile.c b/src/nvim/profile.c
index acbaf09a6e..8402817710 100644
--- a/src/nvim/profile.c
+++ b/src/nvim/profile.c
@@ -299,7 +299,7 @@ void ex_profile(exarg_T *eap)
 
   if (len == 5 && strncmp(eap->arg, "start", 5) == 0 && *e != NUL) {
     xfree(profile_fname);
-    profile_fname = (char *)expand_env_save_opt(e, true);
+    profile_fname = expand_env_save_opt(e, true);
     do_profiling = PROF_YES;
     profile_set_wait(profile_zero());
     set_vim_var_nr(VV_PROFILING, 1L);
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index 54461bfa07..ab8e974b29 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -361,7 +361,7 @@ static int nextchr;             // used for ungetchr()
 #define REG_NPAREN      3       // \%(\)
 
 typedef struct {
-  char_u *regparse;
+  char *regparse;
   int prevchr_len;
   int curchr;
   int prevchr;
@@ -393,12 +393,12 @@ static int get_equi_class(char **pp)
 {
   int c;
   int l = 1;
-  char_u *p = (char_u *)(*pp);
+  char *p = *pp;
 
   if (p[1] == '=' && p[2] != NUL) {
-    l = utfc_ptr2len((char *)p + 2);
+    l = utfc_ptr2len(p + 2);
     if (p[l + 2] == '=' && p[l + 3] == ']') {
-      c = utf_ptr2char((char *)p + 2);
+      c = utf_ptr2char(p + 2);
       *pp += l + 4;
       return c;
     }
@@ -414,12 +414,12 @@ static int get_coll_element(char **pp)
 {
   int c;
   int l = 1;
-  char_u *p = (char_u *)(*pp);
+  char *p = *pp;
 
   if (p[0] != NUL && p[1] == '.' && p[2] != NUL) {
-    l = utfc_ptr2len((char *)p + 2);
+    l = utfc_ptr2len(p + 2);
     if (p[l + 2] == '.' && p[l + 3] == ']') {
-      c = utf_ptr2char((char *)p + 2);
+      c = utf_ptr2char(p + 2);
       *pp += l + 4;
       return c;
     }
@@ -437,7 +437,7 @@ static void get_cpo_flags(void)
 /// Skip over a "[]" range.
 /// "p" must point to the character after the '['.
 /// The returned pointer is on the matching ']', or the terminating NUL.
-static char_u *skip_anyof(char *p)
+static char *skip_anyof(char *p)
 {
   int l;
 
@@ -472,7 +472,7 @@ static char_u *skip_anyof(char *p)
     }
   }
 
-  return (char_u *)p;
+  return p;
 }
 
 /// Skip past regular expression.
@@ -522,7 +522,7 @@ char *skip_regexp_ex(char *startp, int dirc, int magic, char **newp, int *droppe
     }
     if ((p[0] == '[' && mymagic >= MAGIC_ON)
         || (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF)) {
-      p = (char *)skip_anyof(p + 1);
+      p = skip_anyof(p + 1);
       if (p[0] == NUL) {
         break;
       }
@@ -559,9 +559,9 @@ static int at_start;       // True when on the first character
 static int prev_at_start;  // True when on the second character
 
 // Start parsing at "str".
-static void initchr(char_u *str)
+static void initchr(char *str)
 {
-  regparse = (char *)str;
+  regparse = str;
   prevchr_len = 0;
   curchr = prevprevchr = prevchr = nextchr = -1;
   at_start = true;
@@ -572,7 +572,7 @@ static void initchr(char_u *str)
 // starts in the same state again.
 static void save_parse_state(parse_state_T *ps)
 {
-  ps->regparse = (char_u *)regparse;
+  ps->regparse = regparse;
   ps->prevchr_len = prevchr_len;
   ps->curchr = curchr;
   ps->prevchr = prevchr;
@@ -586,7 +586,7 @@ static void save_parse_state(parse_state_T *ps)
 // Restore a previously saved parse state.
 static void restore_parse_state(parse_state_T *ps)
 {
-  regparse = (char *)ps->regparse;
+  regparse = ps->regparse;
   prevchr_len = ps->prevchr_len;
   curchr = ps->curchr;
   prevchr = ps->prevchr;
@@ -892,7 +892,7 @@ static int64_t getoctchrs(void)
 static int read_limits(long *minval, long *maxval)
 {
   int reverse = false;
-  char_u *first_char;
+  char *first_char;
   long tmp;
 
   if (*regparse == '-') {
@@ -900,7 +900,7 @@ static int read_limits(long *minval, long *maxval)
     regparse++;
     reverse = true;
   }
-  first_char = (char_u *)regparse;
+  first_char = regparse;
   *minval = getdigits_long(&regparse, false, 0);
   if (*regparse == ',') {           // There is a comma.
     if (ascii_isdigit(*++regparse)) {
@@ -1019,7 +1019,7 @@ static bool reg_iswordc(int c)
 }
 
 // Get pointer to the line "lnum", which is relative to "reg_firstlnum".
-static char_u *reg_getline(linenr_T lnum)
+static char *reg_getline(linenr_T lnum)
 {
   // when looking behind for a match/no-match lnum is negative.  But we
   // can't go before line 1
@@ -1028,9 +1028,9 @@ static char_u *reg_getline(linenr_T lnum)
   }
   if (lnum > rex.reg_maxline) {
     // Must have matched the "\n" in the last line.
-    return (char_u *)"";
+    return "";
   }
-  return (char_u *)ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, false);
+  return ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, false);
 }
 
 static char_u *reg_startzp[NSUBEXP];  // Workspace to mark beginning
@@ -1147,7 +1147,7 @@ static bool reg_match_visual(void)
     }
 
     // getvvcol() flushes rex.line, need to get it again
-    rex.line = reg_getline(rex.lnum);
+    rex.line = (char_u *)reg_getline(rex.lnum);
     rex.input = rex.line + col;
 
     unsigned int cols_u = win_linetabsize(wp, rex.reg_firstlnum + rex.lnum, (char *)rex.line, col);
@@ -1190,8 +1190,8 @@ static void cleanup_subexpr(void)
       memset(rex.reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP);
       memset(rex.reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP);
     } else {
-      memset(rex.reg_startp, 0, sizeof(char_u *) * NSUBEXP);
-      memset(rex.reg_endp, 0, sizeof(char_u *) * NSUBEXP);
+      memset(rex.reg_startp, 0, sizeof(char *) * NSUBEXP);
+      memset(rex.reg_endp, 0, sizeof(char *) * NSUBEXP);
     }
     rex.need_clear_subexpr = false;
   }
@@ -1205,8 +1205,8 @@ static void cleanup_zsubexpr(void)
       memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
       memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
     } else {
-      memset(reg_startzp, 0, sizeof(char_u *) * NSUBEXP);
-      memset(reg_endzp, 0, sizeof(char_u *) * NSUBEXP);
+      memset(reg_startzp, 0, sizeof(char *) * NSUBEXP);
+      memset(reg_endzp, 0, sizeof(char *) * NSUBEXP);
     }
     rex.need_clear_zsubexpr = false;
   }
@@ -1215,7 +1215,7 @@ static void cleanup_zsubexpr(void)
 // Advance rex.lnum, rex.line and rex.input to the next line.
 static void reg_nextline(void)
 {
-  rex.line = reg_getline(++rex.lnum);
+  rex.line = (char_u *)reg_getline(++rex.lnum);
   rex.input = rex.line;
   fast_breakcheck();
 }
@@ -1252,7 +1252,7 @@ static int match_with_backref(linenr_T start_lnum, colnr_T start_col, linenr_T e
     }
 
     // Get the line to compare with.
-    p = (char *)reg_getline(clnum);
+    p = reg_getline(clnum);
     assert(p);
 
     if (clnum == end_lnum) {
@@ -1434,21 +1434,21 @@ static int cstrncmp(char *s1, char *s2, int *n)
 /// @param  c  character to find in @a s
 ///
 /// @return  NULL if no match, otherwise pointer to the position in @a s
-static inline char_u *cstrchr(const char_u *const s, const int c)
+static inline char *cstrchr(const char *const s, const int c)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
   FUNC_ATTR_ALWAYS_INLINE
 {
   if (!rex.reg_ic) {
-    return (char_u *)vim_strchr((char *)s, c);
+    return vim_strchr(s, c);
   }
 
   // Use folded case for UTF-8, slow! For ASCII use libc strpbrk which is
   // expected to be highly optimized.
   if (c > 0x80) {
     const int folded_c = utf_fold(c);
-    for (const char_u *p = s; *p != NUL; p += utfc_ptr2len((char *)p)) {
-      if (utf_fold(utf_ptr2char((char *)p)) == folded_c) {
-        return (char_u *)p;
+    for (const char *p = s; *p != NUL; p += utfc_ptr2len(p)) {
+      if (utf_fold(utf_ptr2char(p)) == folded_c) {
+        return (char *)p;
       }
     }
     return NULL;
@@ -1460,11 +1460,11 @@ static inline char_u *cstrchr(const char_u *const s, const int c)
   } else if (ASCII_ISLOWER(c)) {
     cc = TOUPPER_ASC(c);
   } else {
-    return (char_u *)vim_strchr((char *)s, c);
+    return vim_strchr(s, c);
   }
 
   char tofind[] = { (char)c, (char)cc, NUL };
-  return (char_u *)strpbrk((const char *)s, tofind);
+  return strpbrk(s, tofind);
 }
 
 ////////////////////////////////////////////////////////////////
@@ -1636,8 +1636,7 @@ static void clear_submatch_list(staticList10_T *sl)
 /// references invalid!
 ///
 /// Returns the size of the replacement, including terminating NUL.
-int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest, int destlen,
-               int flags)
+int vim_regsub(regmatch_T *rmp, char *source, typval_T *expr, char *dest, int destlen, int flags)
 {
   regexec_T rex_save;
   bool rex_in_use_save = rex_in_use;
@@ -1653,7 +1652,7 @@ int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest, in
   rex.reg_maxline = 0;
   rex.reg_buf = curbuf;
   rex.reg_line_lbr = true;
-  int result = vim_regsub_both((char *)source, expr, (char *)dest, destlen, flags);
+  int result = vim_regsub_both(source, expr, dest, destlen, flags);
 
   rex_in_use = rex_in_use_save;
   if (rex_in_use) {
@@ -1663,7 +1662,7 @@ int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest, in
   return result;
 }
 
-int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int destlen,
+int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char *source, char *dest, int destlen,
                      int flags)
 {
   regexec_T rex_save;
@@ -1681,7 +1680,7 @@ int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *de
   rex.reg_firstlnum = lnum;
   rex.reg_maxline = curbuf->b_ml.ml_line_count - lnum;
   rex.reg_line_lbr = false;
-  int result = vim_regsub_both((char *)source, NULL, (char *)dest, destlen, flags);
+  int result = vim_regsub_both(source, NULL, dest, destlen, flags);
 
   rex_in_use = rex_in_use_save;
   if (rex_in_use) {
@@ -1974,7 +1973,7 @@ static int vim_regsub_both(char *source, typval_T *expr, char *dest, int destlen
           if (clnum < 0 || rex.reg_mmatch->endpos[no].lnum < 0) {
             s = NULL;
           } else {
-            s = (char *)reg_getline(clnum) + rex.reg_mmatch->startpos[no].col;
+            s = reg_getline(clnum) + rex.reg_mmatch->startpos[no].col;
             if (rex.reg_mmatch->endpos[no].lnum == clnum) {
               len = rex.reg_mmatch->endpos[no].col
                     - rex.reg_mmatch->startpos[no].col;
@@ -2005,7 +2004,7 @@ static int vim_regsub_both(char *source, typval_T *expr, char *dest, int destlen
                   *dst = CAR;
                 }
                 dst++;
-                s = (char *)reg_getline(++clnum);
+                s = reg_getline(++clnum);
                 if (rex.reg_mmatch->endpos[no].lnum == clnum) {
                   len = rex.reg_mmatch->endpos[no].col;
                 } else {
@@ -2099,7 +2098,7 @@ static char *reg_getline_submatch(linenr_T lnum)
   rex.reg_firstlnum = rsm.sm_firstlnum;
   rex.reg_maxline = rsm.sm_maxline;
 
-  s = (char *)reg_getline(lnum);
+  s = reg_getline(lnum);
 
   rex.reg_firstlnum = save_first;
   rex.reg_maxline = save_max;
@@ -2366,7 +2365,7 @@ regprog_T *vim_regcomp(char *expr_arg, int re_flags)
     // But don't try if an error message was given.
     if (regexp_engine == AUTOMATIC_ENGINE && called_emsg == called_emsg_before) {
       regexp_engine = BACKTRACKING_ENGINE;
-      report_re_switch((char_u *)expr);
+      report_re_switch(expr);
       prog = bt_regengine.regcomp((char_u *)expr, re_flags);
     }
   }
@@ -2400,12 +2399,12 @@ void free_regexp_stuff(void)
 
 #endif
 
-static void report_re_switch(char_u *pat)
+static void report_re_switch(char *pat)
 {
   if (p_verbose > 0) {
     verbose_enter();
     msg_puts(_("Switching to backtracking RE engine for pattern: "));
-    msg_puts((char *)pat);
+    msg_puts(pat);
     verbose_leave();
   }
 }
@@ -2422,7 +2421,7 @@ static void report_re_switch(char_u *pat)
 /// @param nl
 ///
 /// @return true if there is a match, false if not.
-static bool vim_regexec_string(regmatch_T *rmp, char_u *line, colnr_T col, bool nl)
+static bool vim_regexec_string(regmatch_T *rmp, char *line, colnr_T col, bool nl)
 {
   regexec_T rex_save;
   bool rex_in_use_save = rex_in_use;
@@ -2445,7 +2444,7 @@ static bool vim_regexec_string(regmatch_T *rmp, char_u *line, colnr_T col, bool
   rex.reg_startpos = NULL;
   rex.reg_endpos = NULL;
 
-  int result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl);
+  int result = rmp->regprog->engine->regexec_nl(rmp, (char_u *)line, col, nl);
   rmp->regprog->re_in_use = false;
 
   // NFA engine aborted because it's very slow, use backtracking engine instead.
@@ -2457,11 +2456,11 @@ static bool vim_regexec_string(regmatch_T *rmp, char_u *line, colnr_T col, bool
 
     p_re = BACKTRACKING_ENGINE;
     vim_regfree(rmp->regprog);
-    report_re_switch((char_u *)pat);
+    report_re_switch(pat);
     rmp->regprog = vim_regcomp(pat, re_flags);
     if (rmp->regprog != NULL) {
       rmp->regprog->re_in_use = true;
-      result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl);
+      result = rmp->regprog->engine->regexec_nl(rmp, (char_u *)line, col, nl);
       rmp->regprog->re_in_use = false;
     }
 
@@ -2479,7 +2478,7 @@ static bool vim_regexec_string(regmatch_T *rmp, char_u *line, colnr_T col, bool
 
 // Note: "*prog" may be freed and changed.
 // Return true if there is a match, false if not.
-bool vim_regexec_prog(regprog_T **prog, bool ignore_case, char_u *line, colnr_T col)
+bool vim_regexec_prog(regprog_T **prog, bool ignore_case, char *line, colnr_T col)
 {
   regmatch_T regmatch = { .regprog = *prog, .rm_ic = ignore_case };
   bool r = vim_regexec_string(&regmatch, line, col, false);
@@ -2491,7 +2490,7 @@ bool vim_regexec_prog(regprog_T **prog, bool ignore_case, char_u *line, colnr_T
 // Return true if there is a match, false if not.
 bool vim_regexec(regmatch_T *rmp, char *line, colnr_T col)
 {
-  return vim_regexec_string(rmp, (char_u *)line, col, false);
+  return vim_regexec_string(rmp, line, col, false);
 }
 
 // Like vim_regexec(), but consider a "\n" in "line" to be a line break.
@@ -2499,7 +2498,7 @@ bool vim_regexec(regmatch_T *rmp, char *line, colnr_T col)
 // Return true if there is a match, false if not.
 bool vim_regexec_nl(regmatch_T *rmp, char *line, colnr_T col)
 {
-  return vim_regexec_string(rmp, (char_u *)line, col, true);
+  return vim_regexec_string(rmp, line, col, true);
 }
 
 /// Match a regexp against multiple lines.
@@ -2549,7 +2548,7 @@ long vim_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum,
     p_re = BACKTRACKING_ENGINE;
     regprog_T *prev_prog = rmp->regprog;
 
-    report_re_switch((char_u *)pat);
+    report_re_switch(pat);
     // checking for \z misuse was already done when compiling for NFA,
     // allow all here
     reg_do_extmatch = REX_ALL;
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index a047c51145..611d24c091 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -430,7 +430,7 @@ static int regnarrate = 0;
 // Setup to parse the regexp.  Used once to get the length and once to do it.
 static void regcomp_start(char_u *expr, int re_flags)                        // see vim_regcomp()
 {
-  initchr(expr);
+  initchr((char *)expr);
   if (re_flags & RE_MAGIC) {
     reg_magic = MAGIC_ON;
   } else {
@@ -2128,7 +2128,7 @@ collection:
 
       // If there is no matching ']', we assume the '[' is a normal
       // character.  This makes 'incsearch' and ":help [" work.
-      lp = skip_anyof(regparse);
+      lp = (char_u *)skip_anyof(regparse);
       if (*lp == ']') {         // there is a matching ']'
         int startc = -1;                // > 0 when next '-' is a range
         int endc;
@@ -3014,7 +3014,7 @@ static void reg_restore(regsave_T *save, garray_T *gap)
       // only call reg_getline() when the line number changed to save
       // a bit of time
       rex.lnum = save->rs_u.pos.lnum;
-      rex.line = reg_getline(rex.lnum);
+      rex.line = (char_u *)reg_getline(rex.lnum);
     }
     rex.input = rex.line + save->rs_u.pos.col;
   } else {
@@ -3385,12 +3385,12 @@ do_class:
       } else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) {
         scan++;
       } else if ((len = utfc_ptr2len((char *)scan)) > 1) {
-        if ((cstrchr(opnd, utf_ptr2char((char *)scan)) == NULL) == testval) {
+        if ((cstrchr((char *)opnd, utf_ptr2char((char *)scan)) == NULL) == testval) {
           break;
         }
         scan += len;
       } else {
-        if ((cstrchr(opnd, *scan) == NULL) == testval) {
+        if ((cstrchr((char *)opnd, *scan) == NULL) == testval) {
           break;
         }
         scan++;
@@ -3647,7 +3647,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
 
           // Line may have been freed, get it again.
           if (REG_MULTI) {
-            rex.line = reg_getline(rex.lnum);
+            rex.line = (char_u *)reg_getline(rex.lnum);
             rex.input = rex.line + col;
           }
 
@@ -4003,7 +4003,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
         case ANYBUT:
           if (c == NUL) {
             status = RA_NOMATCH;
-          } else if ((cstrchr(OPERAND(scan), c) == NULL) == (op == ANYOF)) {
+          } else if ((cstrchr((char *)OPERAND(scan), c) == NULL) == (op == ANYOF)) {
             status = RA_NOMATCH;
           } else {
             ADVANCE_REGINPUT();
@@ -4700,7 +4700,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
               }
             } else {
               const char_u *const line =
-                reg_getline(rp->rs_un.regsave.rs_u.pos.lnum);
+                (char_u *)reg_getline(rp->rs_un.regsave.rs_u.pos.lnum);
 
               rp->rs_un.regsave.rs_u.pos.col -=
                 utf_head_off((char *)line,
@@ -4782,7 +4782,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
                   break;
                 }
                 rex.lnum--;
-                rex.line = reg_getline(rex.lnum);
+                rex.line = (char_u *)reg_getline(rex.lnum);
                 // Just in case regrepeat() didn't count right.
                 if (rex.line == NULL) {
                   break;
@@ -4962,7 +4962,7 @@ static long bt_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
 
   if (REG_MULTI) {
     prog = (bt_regprog_T *)rex.reg_mmatch->regprog;
-    line = reg_getline((linenr_T)0);
+    line = (char_u *)reg_getline((linenr_T)0);
     rex.reg_startpos = rex.reg_mmatch->startpos;
     rex.reg_endpos = rex.reg_mmatch->endpos;
   } else {
@@ -5014,7 +5014,7 @@ static long bt_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
         MB_PTR_ADV(s);
       }
     } else {
-      while ((s = cstrchr(s, c)) != NULL) {
+      while ((s = (char_u *)cstrchr((char *)s, c)) != NULL) {
         if (cstrncmp((char *)s, (char *)prog->regmust, &prog->regmlen) == 0) {
           break;  // Found it.
         }
@@ -5049,7 +5049,7 @@ static long bt_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
     while (!got_int) {
       if (prog->regstart != NUL) {
         // Skip until the char we know it must start with.
-        s = cstrchr(rex.line + col, prog->regstart);
+        s = (char_u *)cstrchr((char *)rex.line + col, prog->regstart);
         if (s == NULL) {
           retval = 0;
           break;
@@ -5071,7 +5071,7 @@ static long bt_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
       // if not currently on the first line, get it again
       if (rex.lnum != 0) {
         rex.lnum = 0;
-        rex.line = reg_getline((linenr_T)0);
+        rex.line = (char_u *)reg_getline((linenr_T)0);
       }
       if (rex.line[col] == NUL) {
         break;
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index 66a31f0184..aaa8073240 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -2218,7 +2218,7 @@ collection:
     // - ranges, two characters followed by NFA_RANGE.
 
     p = (char_u *)regparse;
-    endp = skip_anyof((char *)p);
+    endp = (char_u *)skip_anyof((char *)p);
     if (*endp == ']') {
       // Try to reverse engineer character classes. For example,
       // recognize that [0-9] stands for \d and [A-Za-z_] for \h,
@@ -5522,10 +5522,10 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
     // bytes if possible.
     if (state->val <= 0) {
       if (REG_MULTI) {
-        rex.line = reg_getline(--rex.lnum);
+        rex.line = (char_u *)reg_getline(--rex.lnum);
         if (rex.line == NULL) {
           // can't go before the first line
-          rex.line = reg_getline(++rex.lnum);
+          rex.line = (char_u *)reg_getline(++rex.lnum);
         }
       }
       rex.input = rex.line;
@@ -5533,10 +5533,10 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
       if (REG_MULTI && (int)(rex.input - rex.line) < state->val) {
         // Not enough bytes in this line, go to end of
         // previous line.
-        rex.line = reg_getline(--rex.lnum);
+        rex.line = (char_u *)reg_getline(--rex.lnum);
         if (rex.line == NULL) {
           // can't go before the first line
-          rex.line = reg_getline(++rex.lnum);
+          rex.line = (char_u *)reg_getline(++rex.lnum);
           rex.input = rex.line;
         } else {
           rex.input = rex.line + strlen((char *)rex.line);
@@ -5595,7 +5595,7 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
   // restore position in input text
   rex.lnum = save_reglnum;
   if (REG_MULTI) {
-    rex.line = reg_getline(rex.lnum);
+    rex.line = (char_u *)reg_getline(rex.lnum);
   }
   rex.input = rex.line + save_reginput_col;
   if (result != NFA_TOO_EXPENSIVE) {
@@ -5772,7 +5772,7 @@ static int failure_chance(nfa_state_T *state, int depth)
 // Skip until the char "c" we know a match must start with.
 static int skip_to_start(int c, colnr_T *colp)
 {
-  const char_u *const s = cstrchr(rex.line + *colp, c);
+  const char_u *const s = (char_u *)cstrchr((char *)rex.line + *colp, c);
   if (s == NULL) {
     return FAIL;
   }
@@ -6860,7 +6860,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *subm
 
         // Line may have been freed, get it again.
         if (REG_MULTI) {
-          rex.line = reg_getline(rex.lnum);
+          rex.line = (char_u *)reg_getline(rex.lnum);
           rex.input = rex.line + col;
         }
 
@@ -7333,7 +7333,7 @@ static long nfa_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
 
   if (REG_MULTI) {
     prog = (nfa_regprog_T *)rex.reg_mmatch->regprog;
-    line = reg_getline((linenr_T)0);  // relative to the cursor
+    line = (char_u *)reg_getline((linenr_T)0);  // relative to the cursor
     rex.reg_startpos = rex.reg_mmatch->startpos;
     rex.reg_endpos = rex.reg_mmatch->endpos;
   } else {
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 92d47fbf49..95151936c1 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1482,7 +1482,7 @@ static char *shada_filename(const char *file)
     if (p_shadafile != NULL && *p_shadafile != NUL) {
       file = p_shadafile;
     } else {
-      if ((file = (char *)find_shada_parameter('n')) == NULL || *file == NUL) {
+      if ((file = find_shada_parameter('n')) == NULL || *file == NUL) {
         file = shada_get_default_file();
       }
       // XXX It used to be one level lower, so that whatever is in
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index e211b0069e..753c814110 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -99,7 +99,7 @@ static signgroup_T *sign_group_ref(const char *groupname)
   hashitem_T *hi;
   signgroup_T *group;
 
-  hash = hash_hash((char_u *)groupname);
+  hash = hash_hash(groupname);
   hi = hash_lookup(&sg_table, (char *)groupname, strlen(groupname), hash);
   if (HASHITEM_EMPTY(hi)) {
     // new group
@@ -108,7 +108,7 @@ static signgroup_T *sign_group_ref(const char *groupname)
     STRCPY(group->sg_name, groupname);
     group->sg_refcount = 1;
     group->sg_next_sign_id = 1;
-    hash_add_item(&sg_table, hi, (char_u *)group->sg_name, hash);
+    hash_add_item(&sg_table, hi, group->sg_name, hash);
   } else {
     // existing group
     group = HI2SG(hi);
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 6f2c56f3b1..e4c5779a08 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -687,7 +687,8 @@ static void find_word(matchinf_T *mip, int mode)
         }
 
         // Quickly check if compounding is possible with this flag.
-        if (!byte_in_str(mip->mi_complen == 0 ? slang->sl_compstartflags : slang->sl_compallflags,
+        if (!byte_in_str(mip->mi_complen ==
+                         0 ? slang->sl_compstartflags : slang->sl_compallflags,
                          (int)((unsigned)flags >> 24))) {
           continue;
         }
@@ -942,7 +943,7 @@ bool can_compound(slang_T *slang, const char *word, const uint8_t *flags)
   }
   *p = NUL;
   p = uflags;
-  if (!vim_regexec_prog(&slang->sl_compprog, false, (char_u *)p, 0)) {
+  if (!vim_regexec_prog(&slang->sl_compprog, false, p, 0)) {
     return false;
   }
 
@@ -1035,7 +1036,7 @@ int valid_word_prefix(int totprefcnt, int arridx, int flags, char *word, slang_T
     // stored in the two bytes above the prefix ID byte.
     regprog_T **rp = &slang->sl_prefprog[((unsigned)pidx >> 8) & 0xffff];
     if (*rp != NULL) {
-      if (!vim_regexec_prog(rp, false, (char_u *)word, 0)) {
+      if (!vim_regexec_prog(rp, false, word, 0)) {
         continue;
       }
     } else if (cond_req) {
@@ -1736,14 +1737,14 @@ void count_common_word(slang_T *lp, char *word, int len, uint8_t count)
   }
 
   wordcount_T *wc;
-  hash_T hash = hash_hash((char_u *)p);
+  hash_T hash = hash_hash(p);
   const size_t p_len = strlen(p);
   hashitem_T *hi = hash_lookup(&lp->sl_wordcount, (const char *)p, p_len, hash);
   if (HASHITEM_EMPTY(hi)) {
     wc = xmalloc(sizeof(wordcount_T) + p_len);
     memcpy(wc->wc_word, p, p_len + 1);
     wc->wc_count = count;
-    hash_add_item(&lp->sl_wordcount, hi, wc->wc_word, hash);
+    hash_add_item(&lp->sl_wordcount, hi, (char *)wc->wc_word, hash);
   } else {
     wc = HI2WC(hi);
     wc->wc_count = (uint16_t)(wc->wc_count + count);
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index a7219e23dd..4725c9aea6 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -3218,7 +3218,7 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
       break;
     }
 
-    hash = hash_hash((char_u *)dw);
+    hash = hash_hash(dw);
     hi = hash_lookup(&ht, (const char *)dw, strlen(dw), hash);
     if (!HASHITEM_EMPTY(hi)) {
       if (p_verbose > 0) {
@@ -3230,7 +3230,7 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
       }
       duplicate++;
     } else {
-      hash_add_item(&ht, hi, (char_u *)dw, hash);
+      hash_add_item(&ht, hi, dw, hash);
     }
 
     flags = 0;
@@ -3465,7 +3465,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               && (ae->ae_chop == NULL
                   || strlen(ae->ae_chop) < wordlen)
               && (ae->ae_prog == NULL
-                  || vim_regexec_prog(&ae->ae_prog, false, (char_u *)word, (colnr_T)0))
+                  || vim_regexec_prog(&ae->ae_prog, false, word, (colnr_T)0))
               && (((condit & CONDIT_CFIX) == 0)
                   == ((condit & CONDIT_AFF) == 0
                       || ae->ae_flags == NULL
@@ -4255,7 +4255,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
       compressed += node_compress(spin, child, ht, tot);
 
       // Try to find an identical child.
-      hash = hash_hash(child->wn_u1.hashkey);
+      hash = hash_hash((char *)child->wn_u1.hashkey);
       hi = hash_lookup(ht, (const char *)child->wn_u1.hashkey,
                        strlen((char *)child->wn_u1.hashkey), hash);
       if (!HASHITEM_EMPTY(hi)) {
@@ -4284,7 +4284,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
       } else {
         // No other child has this hash value, add it to the
         // hashtable.
-        hash_add_item(ht, hi, child->wn_u1.hashkey, hash);
+        hash_add_item(ht, hi, (char *)child->wn_u1.hashkey, hash);
       }
     }
   }
@@ -5877,10 +5877,10 @@ static void set_map_str(slang_T *lp, char *map)
         b[cl] = NUL;
         utf_char2bytes(headc, b + cl + 1);
         b[cl + 1 + headcl] = NUL;
-        hash = hash_hash((char_u *)b);
+        hash = hash_hash(b);
         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);
+          hash_add_item(&lp->sl_map_hash, hi, b, hash);
         } else {
           // This should have been checked when generating the .spl
           // file.
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index aa5e13d08a..7823a411f3 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -2819,7 +2819,7 @@ static void add_sound_suggest(suginfo_T *su, char *goodword, int score, langp_T
   // times with different scores.  Since the following is quite slow only do
   // the words that have a better score than before.  Use a hashtable to
   // remember the words that have been done.
-  hash = hash_hash((char_u *)goodword);
+  hash = hash_hash(goodword);
   const size_t goodword_len = strlen(goodword);
   hi = hash_lookup(&slang->sl_sounddone, (const char *)goodword, goodword_len,
                    hash);
@@ -2827,7 +2827,7 @@ static void add_sound_suggest(suginfo_T *su, char *goodword, int score, langp_T
     sft = xmalloc(sizeof(sftword_T) + goodword_len);
     sft->sft_score = (int16_t)score;
     memcpy(sft->sft_word, goodword, goodword_len + 1);
-    hash_add_item(&slang->sl_sounddone, hi, sft->sft_word, hash);
+    hash_add_item(&slang->sl_sounddone, hi, (char *)sft->sft_word, hash);
   } else {
     sft = HI2SFT(hi);
     if (score >= sft->sft_score) {
@@ -3244,12 +3244,12 @@ static void add_banned(suginfo_T *su, char *word)
   hash_T hash;
   hashitem_T *hi;
 
-  hash = hash_hash((char_u *)word);
+  hash = hash_hash(word);
   const size_t word_len = strlen(word);
   hi = hash_lookup(&su->su_banned, word, word_len, hash);
   if (HASHITEM_EMPTY(hi)) {
     s = xmemdupz(word, word_len);
-    hash_add_item(&su->su_banned, hi, s, hash);
+    hash_add_item(&su->su_banned, hi, (char *)s, hash);
   }
 }
 
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index 0658919cc9..0639615b8b 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -715,7 +715,7 @@ void draw_tabline(void)
   int len;
   int attr_nosel = HL_ATTR(HLF_TP);
   int attr_fill = HL_ATTR(HLF_TPF);
-  char_u *p;
+  char *p;
   int room;
   int use_sep_chars = (t_colors < 8);
 
@@ -815,16 +815,16 @@ void draw_tabline(void)
         get_trans_bufname(cwp->w_buffer);
         shorten_dir(NameBuff);
         len = vim_strsize(NameBuff);
-        p = (char_u *)NameBuff;
+        p = NameBuff;
         while (len > room) {
-          len -= ptr2cells((char *)p);
+          len -= ptr2cells(p);
           MB_PTR_ADV(p);
         }
         if (len > Columns - col - 1) {
           len = Columns - col - 1;
         }
 
-        grid_puts_len(&default_grid, (char *)p, (int)strlen((char *)p), 0, col, attr);
+        grid_puts_len(&default_grid, p, (int)strlen(p), 0, col, attr);
         col += len;
       }
       grid_putchar(&default_grid, ' ', 0, col++, attr);
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 78f650ab76..46cd6245a7 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -92,7 +92,7 @@ typedef struct syn_pattern {
 } synpat_T;
 
 typedef struct syn_cluster_S {
-  char_u *scl_name;         // syntax cluster name
+  char *scl_name;           // syntax cluster name
   char *scl_name_u;         // uppercase of scl_name
   int16_t *scl_list;        // IDs in this syntax cluster
 } syn_cluster_T;
@@ -3453,7 +3453,7 @@ static void syn_list_cluster(int id)
 
   // slight hack:  roughly duplicate the guts of syn_list_header()
   msg_putchar('\n');
-  msg_outtrans((char *)SYN_CLSTR(curwin->w_s)[id].scl_name);
+  msg_outtrans(SYN_CLSTR(curwin->w_s)[id].scl_name);
 
   if (msg_col >= endcol) {      // output at least one space
     endcol = msg_col + 1;
@@ -3490,7 +3490,7 @@ static void put_id_list(const char *const name, const int16_t *const list, const
       int scl_id = *p - SYNID_CLUSTER;
 
       msg_putchar('@');
-      msg_outtrans((char *)SYN_CLSTR(curwin->w_s)[scl_id].scl_name);
+      msg_outtrans(SYN_CLSTR(curwin->w_s)[scl_id].scl_name);
     } else {
       msg_outtrans(highlight_group_name(*p - 1));
     }
@@ -3743,7 +3743,7 @@ static void add_keyword(char *const name, const int id, const int flags,
   }
   kp->next_list = copy_id_list(next_list);
 
-  const hash_T hash = hash_hash((char_u *)kp->keyword);
+  const hash_T hash = hash_hash(kp->keyword);
   hashtab_T *const ht = (curwin->w_s->b_syn_ic)
       ? &curwin->w_s->b_keywtab_ic
       : &curwin->w_s->b_keywtab;
@@ -3757,7 +3757,7 @@ static void add_keyword(char *const name, const int id, const int flags,
   if (HASHITEM_EMPTY(hi)) {
     // new keyword, add to hashtable
     kp->ke_next = NULL;
-    hash_add_item(ht, hi, (char_u *)kp->keyword, hash);
+    hash_add_item(ht, hi, kp->keyword, hash);
   } else {
     // keyword already exists, prepend to list
     kp->ke_next = HI2KE(hi);
@@ -4634,7 +4634,7 @@ static int syn_add_cluster(char *name)
   syn_cluster_T *scp = GA_APPEND_VIA_PTR(syn_cluster_T,
                                          &curwin->w_s->b_syn_clusters);
   CLEAR_POINTER(scp);
-  scp->scl_name = (char_u *)name;
+  scp->scl_name = name;
   scp->scl_name_u = vim_strsave_up(name);
   scp->scl_list = NULL;
 
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 75a2849fbd..0d52f73ce7 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -2078,10 +2078,10 @@ static void findtags_add_match(findtags_state_T *st, tagptrs_T *tagpp, findtags_
     // the part that matters for comparing, more bytes may
     // follow after it.  E.g. help tags store the priority
     // after the NUL.
-    *hash = hash_hash((char_u *)mfp);
+    *hash = hash_hash(mfp);
     hi = hash_lookup(&st->ht_match[mtt], (const char *)mfp, strlen(mfp), *hash);
     if (HASHITEM_EMPTY(hi)) {
-      hash_add_item(&st->ht_match[mtt], hi, (char_u *)mfp, *hash);
+      hash_add_item(&st->ht_match[mtt], hi, mfp, *hash);
       GA_APPEND(char *, &st->ga_match[mtt], mfp);
       st->match_count++;
     } else {
@@ -2573,7 +2573,7 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
   // tnp->tn_did_filefind_init == true: find next file in this part.
   for (;;) {
     if (tnp->tn_did_filefind_init) {
-      fname = (char *)vim_findfile(tnp->tn_search_ctx);
+      fname = vim_findfile(tnp->tn_search_ctx);
       if (fname != NULL) {
         break;
       }
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 106e92d43c..a52a34cd66 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -435,7 +435,7 @@ bool terminal_enter(void)
   handle_T save_curwin = curwin->handle;
   bool save_w_p_cul = curwin->w_p_cul;
   char *save_w_p_culopt = NULL;
-  char_u save_w_p_culopt_flags = curwin->w_p_culopt_flags;
+  uint8_t save_w_p_culopt_flags = curwin->w_p_culopt_flags;
   int save_w_p_cuc = curwin->w_p_cuc;
   long save_w_p_so = curwin->w_p_so;
   long save_w_p_siso = curwin->w_p_siso;
@@ -718,7 +718,7 @@ void terminal_paste(long count, char **y_array, size_t y_size)
   }
   vterm_keyboard_start_paste(curbuf->terminal->vt);
   size_t buff_len = strlen(y_array[0]);
-  char_u *buff = xmalloc(buff_len);
+  char *buff = xmalloc(buff_len);
   for (int i = 0; i < count; i++) {  // -V756
     // feed the lines to the terminal
     for (size_t j = 0; j < y_size; j++) {
@@ -731,18 +731,18 @@ void terminal_paste(long count, char **y_array, size_t y_size)
         buff = xrealloc(buff, len);
         buff_len = len;
       }
-      char_u *dst = buff;
-      char_u *src = (char_u *)y_array[j];
+      char *dst = buff;
+      char *src = y_array[j];
       while (*src != '\0') {
-        len = (size_t)utf_ptr2len((char *)src);
-        int c = utf_ptr2char((char *)src);
+        len = (size_t)utf_ptr2len(src);
+        int c = utf_ptr2char(src);
         if (!is_filter_char(c)) {
           memcpy(dst, src, len);
           dst += len;
         }
         src += len;
       }
-      terminal_send(curbuf->terminal, (char *)buff, (size_t)(dst - buff));
+      terminal_send(curbuf->terminal, buff, (size_t)(dst - buff));
     }
   }
   xfree(buff);
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 4af629d091..f2705057ef 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -127,13 +127,13 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
 
     // Don't break until after the comment leader
     if (do_comments) {
-      char_u *line = (char_u *)get_cursor_line_ptr();
-      leader_len = get_leader_len((char *)line, NULL, false, true);
+      char *line = get_cursor_line_ptr();
+      leader_len = get_leader_len(line, NULL, false, true);
       if (leader_len == 0 && curbuf->b_p_cin) {
         // Check for a line comment after code.
-        int comment_start = check_linecomment((char *)line);
+        int comment_start = check_linecomment(line);
         if (comment_start != MAXCOL) {
-          leader_len = get_leader_len((char *)line + comment_start, NULL, false, true);
+          leader_len = get_leader_len(line + comment_start, NULL, false, true);
           if (leader_len != 0) {
             leader_len += comment_start;
           }
@@ -477,25 +477,25 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
 /// comment leader changes.
 static int fmt_check_par(linenr_T lnum, int *leader_len, char **leader_flags, bool do_comments)
 {
-  char_u *flags = NULL;        // init for GCC
-  char_u *ptr;
+  char *flags = NULL;        // init for GCC
+  char *ptr;
 
-  ptr = (char_u *)ml_get(lnum);
+  ptr = ml_get(lnum);
   if (do_comments) {
-    *leader_len = get_leader_len((char *)ptr, leader_flags, false, true);
+    *leader_len = get_leader_len(ptr, leader_flags, false, true);
   } else {
     *leader_len = 0;
   }
 
   if (*leader_len > 0) {
     // Search for 'e' flag in comment leader flags.
-    flags = (char_u *)(*leader_flags);
+    flags = *leader_flags;
     while (*flags && *flags != ':' && *flags != COM_END) {
       flags++;
     }
   }
 
-  return *skipwhite((char *)ptr + *leader_len) == NUL
+  return *skipwhite(ptr + *leader_len) == NUL
          || (*leader_len > 0 && *flags == COM_END)
          || startPS(lnum, NUL, false);
 }
@@ -587,7 +587,7 @@ static bool same_leader(linenr_T lnum, int leader1_len, char *leader1_flags, int
 ///          false when the previous line is in the same paragraph.
 static bool paragraph_start(linenr_T lnum)
 {
-  char_u *p;
+  char *p;
   int leader_len = 0;                // leader len of current line
   char *leader_flags = NULL;         // flags for leader of current line
   int next_leader_len = 0;           // leader len of next line
@@ -596,7 +596,7 @@ static bool paragraph_start(linenr_T lnum)
   if (lnum <= 1) {
     return true;                // start of the file
   }
-  p = (char_u *)ml_get(lnum - 1);
+  p = ml_get(lnum - 1);
   if (*p == NUL) {
     return true;                // after empty line
   }
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 3e4aae62c9..ad16a6eda2 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -1074,9 +1074,9 @@ static u_entry_T *unserialize_uep(bufinfo_T *bi, bool *error, const char *file_n
 
   char_u **array = NULL;
   if (uep->ue_size > 0) {
-    if ((size_t)uep->ue_size < SIZE_MAX / sizeof(char_u *)) {  // -V547
-      array = xmalloc(sizeof(char_u *) * (size_t)uep->ue_size);
-      memset(array, 0, sizeof(char_u *) * (size_t)uep->ue_size);
+    if ((size_t)uep->ue_size < SIZE_MAX / sizeof(char *)) {  // -V547
+      array = xmalloc(sizeof(char *) * (size_t)uep->ue_size);
+      memset(array, 0, sizeof(char *) * (size_t)uep->ue_size);
     }
   }
   uep->ue_array = (char **)array;
@@ -1209,7 +1209,7 @@ void u_write_undo(const char *const name, const bool forceit, buf_T *const buf,
         }
         goto theend;
       } else {
-        char_u mbuf[UF_START_MAGIC_LEN];
+        char mbuf[UF_START_MAGIC_LEN];
         ssize_t len = read_eintr(fd, mbuf, UF_START_MAGIC_LEN);
         close(fd);
         if (len < UF_START_MAGIC_LEN
@@ -1342,8 +1342,8 @@ write_error:
 #ifdef HAVE_ACL
   if (buf->b_ffname != NULL) {
     // For systems that support ACL: get the ACL from the original file.
-    vim_acl_T acl = os_get_acl((char_u *)buf->b_ffname);
-    os_set_acl((char_u *)file_name, acl);
+    vim_acl_T acl = os_get_acl(buf->b_ffname);
+    os_set_acl(file_name, acl);
     os_free_acl(acl);
   }
 #endif
@@ -1363,7 +1363,7 @@ void u_read_undo(char *name, const char_u *hash, const char *orig_name FUNC_ATTR
   FUNC_ATTR_NONNULL_ARG(2)
 {
   u_header_T **uhp_table = NULL;
-  char_u *line_ptr = NULL;
+  char *line_ptr = NULL;
 
   char *file_name;
   if (name == NULL) {
@@ -1414,7 +1414,7 @@ void u_read_undo(char *name, const char_u *hash, const char *orig_name FUNC_ATTR
   };
 
   // Read the undo file header.
-  char_u magic_buf[UF_START_MAGIC_LEN];
+  char magic_buf[UF_START_MAGIC_LEN];
   if (fread(magic_buf, UF_START_MAGIC_LEN, 1, fp) != 1
       || memcmp(magic_buf, UF_START_MAGIC, UF_START_MAGIC_LEN) != 0) {
     semsg(_("E823: Not an undo file: %s"), file_name);
@@ -1426,8 +1426,8 @@ void u_read_undo(char *name, const char_u *hash, const char *orig_name FUNC_ATTR
     goto error;
   }
 
-  char_u read_hash[UNDO_HASH_SIZE];
-  if (!undo_read(&bi, read_hash, UNDO_HASH_SIZE)) {
+  char read_hash[UNDO_HASH_SIZE];
+  if (!undo_read(&bi, (char_u *)read_hash, UNDO_HASH_SIZE)) {
     corruption_error("hash", file_name);
     goto error;
   }
@@ -1453,7 +1453,7 @@ void u_read_undo(char *name, const char_u *hash, const char *orig_name FUNC_ATTR
   }
 
   if (str_len > 0) {
-    line_ptr = undo_read_string(&bi, (size_t)str_len);
+    line_ptr = (char *)undo_read_string(&bi, (size_t)str_len);
   }
   linenr_T line_lnum = (linenr_T)undo_read_4c(&bi);
   colnr_T line_colnr = (colnr_T)undo_read_4c(&bi);
@@ -1608,7 +1608,7 @@ void u_read_undo(char *name, const char_u *hash, const char *orig_name FUNC_ATTR
   curbuf->b_u_oldhead = old_idx < 0 ? NULL : uhp_table[old_idx];
   curbuf->b_u_newhead = new_idx < 0 ? NULL : uhp_table[new_idx];
   curbuf->b_u_curhead = cur_idx < 0 ? NULL : uhp_table[cur_idx];
-  curbuf->b_u_line_ptr = (char *)line_ptr;
+  curbuf->b_u_line_ptr = line_ptr;
   curbuf->b_u_line_lnum = line_lnum;
   curbuf->b_u_line_colnr = line_colnr;
   curbuf->b_u_numhead = num_head;
@@ -2238,7 +2238,7 @@ target_zero:
 /// @param do_buf_event If `true`, send buffer updates.
 static void u_undoredo(int undo, bool do_buf_event)
 {
-  char_u **newarray = NULL;
+  char **newarray = NULL;
   linenr_T newlnum = MAXLNUM;
   u_entry_T *nuep;
   u_entry_T *newlist = NULL;
@@ -2316,13 +2316,13 @@ static void u_undoredo(int undo, bool do_buf_event)
 
     // delete the lines between top and bot and save them in newarray
     if (oldsize > 0) {
-      newarray = xmalloc(sizeof(char_u *) * (size_t)oldsize);
+      newarray = xmalloc(sizeof(char *) * (size_t)oldsize);
       // delete backwards, it goes faster in most cases
       long i;
       linenr_T lnum;
       for (lnum = bot - 1, i = oldsize; --i >= 0; lnum--) {
         // what can we do when we run out of memory?
-        newarray[i] = (char_u *)u_save_line(lnum);
+        newarray[i] = u_save_line(lnum);
         // remember we deleted the last line in the buffer, and a
         // dummy empty line will be inserted
         if (curbuf->b_ml.ml_line_count == 1) {
@@ -2348,7 +2348,7 @@ static void u_undoredo(int undo, bool do_buf_event)
         }
         xfree(uep->ue_array[i]);
       }
-      xfree((char_u *)uep->ue_array);
+      xfree(uep->ue_array);
     }
 
     // Adjust marks
@@ -2378,7 +2378,7 @@ static void u_undoredo(int undo, bool do_buf_event)
     u_newcount += newsize;
     u_oldcount += oldsize;
     uep->ue_size = oldsize;
-    uep->ue_array = (char **)newarray;
+    uep->ue_array = newarray;
     uep->ue_bot = top + newsize + 1;
 
     // insert this entry in front of the new entry list
@@ -2565,11 +2565,11 @@ static void u_undo_end(bool did_undo, bool absolute, bool quiet)
     uhp = curbuf->b_u_newhead;
   }
 
-  char_u msgbuf[80];
+  char msgbuf[80];
   if (uhp == NULL) {
     *msgbuf = NUL;
   } else {
-    undo_fmt_time((char *)msgbuf, sizeof(msgbuf), uhp->uh_time);
+    undo_fmt_time(msgbuf, sizeof(msgbuf), uhp->uh_time);
   }
 
   {
@@ -2935,7 +2935,7 @@ static void u_freeentries(buf_T *buf, u_header_T *uhp, u_header_T **uhpp)
 #ifdef U_DEBUG
   uhp->uh_magic = 0;
 #endif
-  xfree((char_u *)uhp);
+  xfree(uhp);
   buf->b_u_numhead--;
 }
 
@@ -2945,11 +2945,11 @@ static void u_freeentry(u_entry_T *uep, long n)
   while (n > 0) {
     xfree(uep->ue_array[--n]);
   }
-  xfree((char_u *)uep->ue_array);
+  xfree(uep->ue_array);
 #ifdef U_DEBUG
   uep->ue_magic = 0;
 #endif
-  xfree((char_u *)uep);
+  xfree(uep);
 }
 
 /// invalidate the undo buffer; called when storage has already been released
diff --git a/src/nvim/viml/parser/expressions.c b/src/nvim/viml/parser/expressions.c
index 0b19526fa0..e839ff87c8 100644
--- a/src/nvim/viml/parser/expressions.c
+++ b/src/nvim/viml/parser/expressions.c
@@ -1826,7 +1826,7 @@ static void parse_quoted_string(ParserState *const pstate, ExprASTNode *const no
             flags |= FSK_SIMPLIFY;
           }
           const size_t special_len = trans_special(&p, (size_t)(e - p),
-                                                   (char_u *)v_p, flags, false, NULL);
+                                                   v_p, flags, false, NULL);
           if (special_len != 0) {
             v_p += special_len;
           } else {
diff --git a/src/nvim/window.c b/src/nvim/window.c
index f16e9b8436..fdaaeb812e 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -508,7 +508,7 @@ wingotofile:
     CHECK_CMDWIN;
 
     linenr_T lnum = -1;
-    char *ptr = (char *)grab_file_name(Prenum1, &lnum);
+    char *ptr = grab_file_name(Prenum1, &lnum);
     if (ptr != NULL) {
       tabpage_T *oldtab = curtab;
       win_T *oldwin = curwin;
@@ -756,20 +756,20 @@ void win_set_minimal_style(win_T *wp)
 
   // Hide EOB region: use " " fillchar and cleared highlighting
   if (wp->w_p_fcs_chars.eob != ' ') {
-    char_u *old = (char_u *)wp->w_p_fcs;
+    char *old = wp->w_p_fcs;
     wp->w_p_fcs = ((*old == NUL)
                    ? xstrdup("eob: ")
-                   : concat_str((char *)old, ",eob: "));
-    free_string_option((char *)old);
+                   : concat_str(old, ",eob: "));
+    free_string_option(old);
   }
 
   // TODO(bfredl): this could use a highlight namespace directly,
   // and avoid peculiarities around window options
-  char_u *old = (char_u *)wp->w_p_winhl;
+  char *old = wp->w_p_winhl;
   wp->w_p_winhl = ((*old == NUL)
                    ? xstrdup("EndOfBuffer:")
-                   : concat_str((char *)old, ",EndOfBuffer:"));
-  free_string_option((char *)old);
+                   : concat_str(old, ",EndOfBuffer:"));
+  free_string_option(old);
   parse_winhl_opt(wp);
 
   // signcolumn: use 'auto'
@@ -2617,8 +2617,8 @@ static bool close_last_window_tabpage(win_T *win, bool free_buf, tabpage_T *prev
   goto_tabpage_tp(alt_tabpage(), false, true);
 
   // save index for tabclosed event
-  char_u prev_idx[NUMBUFLEN];
-  snprintf((char *)prev_idx, NUMBUFLEN, "%i", tabpage_index(prev_curtab));
+  char prev_idx[NUMBUFLEN];
+  snprintf(prev_idx, NUMBUFLEN, "%i", tabpage_index(prev_curtab));
 
   // Safety check: Autocommands may have closed the window when jumping
   // to the other tab page.
@@ -4064,7 +4064,7 @@ void free_tabpage(tabpage_T *tp)
 ///              tabpage in case of 0.
 /// @param filename Will be passed to apply_autocmds().
 /// @return Was the new tabpage created successfully? FAIL or OK.
-int win_new_tabpage(int after, char_u *filename)
+int win_new_tabpage(int after, char *filename)
 {
   tabpage_T *old_curtab = curtab;
 
@@ -4127,7 +4127,7 @@ int win_new_tabpage(int after, char_u *filename)
 
     apply_autocmds(EVENT_WINNEW, NULL, NULL, false, curbuf);
     apply_autocmds(EVENT_WINENTER, NULL, NULL, false, curbuf);
-    apply_autocmds(EVENT_TABNEW, (char *)filename, (char *)filename, false, curbuf);
+    apply_autocmds(EVENT_TABNEW, filename, filename, false, curbuf);
     apply_autocmds(EVENT_TABENTER, NULL, NULL, false, curbuf);
 
     return OK;
@@ -6757,7 +6757,7 @@ static void frame_add_height(frame_T *frp, int n)
 // Get the file name at the cursor.
 // If Visual mode is active, use the selected text if it's in one line.
 // Returns the name in allocated memory, NULL for failure.
-char_u *grab_file_name(long count, linenr_T *file_lnum)
+char *grab_file_name(long count, linenr_T *file_lnum)
 {
   int options = FNAME_MESS | FNAME_EXP | FNAME_REL | FNAME_UNESC;
   if (VIsual_active) {
@@ -6772,7 +6772,7 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
 
       *file_lnum = (linenr_T)getdigits_long(&p, false, 0);
     }
-    return (char_u *)find_file_name_in_path(ptr, len, options, count, curbuf->b_ffname);
+    return find_file_name_in_path(ptr, len, options, count, curbuf->b_ffname);
   }
   return file_name_at_cursor(options | FNAME_HYP, count, file_lnum);
 }
@@ -6788,11 +6788,11 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
 // FNAME_EXP        expand to path
 // FNAME_HYP        check for hypertext link
 // FNAME_INCL       apply "includeexpr"
-char_u *file_name_at_cursor(int options, long count, linenr_T *file_lnum)
+char *file_name_at_cursor(int options, long count, linenr_T *file_lnum)
 {
-  return file_name_in_line(get_cursor_line_ptr(),
-                           curwin->w_cursor.col, options, count, curbuf->b_ffname,
-                           file_lnum);
+  return (char *)file_name_in_line(get_cursor_line_ptr(),
+                                   curwin->w_cursor.col, options, count, curbuf->b_ffname,
+                                   file_lnum);
 }
 
 /// @param rel_fname  file we are searching relative to