refactor: replace char_u with char 23 (#21798)

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

22 files changed, 524 insertions, 546 deletions

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 13c8e162b6..a53b30dd8a 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -2271,7 +2271,7 @@ Dictionary nvim_eval_statusline(String str, Dict(eval_statusline) *opts, Error *
       if (sp->userhl == 0) {
         grpname = get_default_stl_hl(wp, use_winbar);
       } else if (sp->userhl < 0) {
-        grpname = (char *)syn_id2name(-sp->userhl);
+        grpname = syn_id2name(-sp->userhl);
       } else {
         snprintf(user_group, sizeof(user_group), "User%d", sp->userhl);
         grpname = user_group;
diff --git a/src/nvim/api/win_config.c b/src/nvim/api/win_config.c
index f81d26b486..0ffeac1bff 100644
--- a/src/nvim/api/win_config.c
+++ b/src/nvim/api/win_config.c
@@ -278,7 +278,7 @@ Dictionary nvim_win_get_config(Window window, Error *err)
         String s = cstrn_to_string((const char *)config->border_chars[i], sizeof(schar_T));
 
         int hi_id = config->border_hl_ids[i];
-        char *hi_name = (char *)syn_id2name(hi_id);
+        char *hi_name = syn_id2name(hi_id);
         if (hi_name[0]) {
           ADD(tuple, STRING_OBJ(s));
           ADD(tuple, STRING_OBJ(cstr_to_string((const char *)hi_name)));
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 59891e9899..c876e04f29 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -2349,7 +2349,7 @@ void set_cmd_context(expand_T *xp, char *str, int len, int col, int use_ccline)
   } else if (use_ccline && ccline->input_fn) {
     xp->xp_context = ccline->xp_context;
     xp->xp_pattern = ccline->cmdbuff;
-    xp->xp_arg = (char *)ccline->xp_arg;
+    xp->xp_arg = ccline->xp_arg;
   } else {
     while (nextcomm != NULL) {
       nextcomm = set_one_cmd_context(xp, nextcomm);
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 9b82d50012..bf4563caa1 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -107,10 +107,9 @@ static colnr_T Insstart_textlen;        // length of line when insert started
 static colnr_T Insstart_blank_vcol;     // vcol for first inserted blank
 static bool update_Insstart_orig = true;  // set Insstart_orig to Insstart
 
-static char_u *last_insert = NULL;    // the text of the previous insert,
-                                      // K_SPECIAL is escaped
-static int last_insert_skip;      // nr of chars in front of previous insert
-static int new_insert_skip;       // nr of chars in front of current insert
+static char *last_insert = NULL;        // the text of the previous insert, K_SPECIAL is escaped
+static int last_insert_skip;            // nr of chars in front of previous insert
+static int new_insert_skip;             // nr of chars in front of current insert
 static int did_restart_edit;            // "restart_edit" when calling edit()
 
 static bool can_cindent;                // may do cindenting on this line
@@ -558,12 +557,12 @@ static int insert_execute(VimState *state, int key)
       // completion: Add to "compl_leader".
       if (ins_compl_accept_char(s->c)) {
         // Trigger InsertCharPre.
-        char_u *str = do_insert_char_pre(s->c);
-        char_u *p;
+        char *str = do_insert_char_pre(s->c);
+        char *p;
 
         if (str != NULL) {
           for (p = str; *p != NUL; MB_PTR_ADV(p)) {
-            ins_compl_addleader(utf_ptr2char((char *)p));
+            ins_compl_addleader(utf_ptr2char(p));
           }
           xfree(str);
         } else {
@@ -1122,7 +1121,7 @@ normalchar:
 
     if (!p_paste) {
       // Trigger InsertCharPre.
-      char *str = (char *)do_insert_char_pre(s->c);
+      char *str = do_insert_char_pre(s->c);
       char *p;
 
       if (str != NULL) {
@@ -1544,8 +1543,8 @@ void display_dollar(colnr_T col)
   curwin->w_cursor.col = col;
 
   // If on the last byte of a multi-byte move to the first byte.
-  char_u *p = (char_u *)get_cursor_line_ptr();
-  curwin->w_cursor.col -= utf_head_off((char *)p, (char *)p + col);
+  char *p = get_cursor_line_ptr();
+  curwin->w_cursor.col -= utf_head_off(p, p + col);
   curs_columns(curwin, false);              // Recompute w_wrow and w_wcol
   if (curwin->w_wcol < curwin->w_grid.cols) {
     edit_putchar('$', false);
@@ -1579,7 +1578,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   int last_vcol;
   int insstart_less;                    // reduction for Insstart.col
   int new_cursor_col;
-  char_u *ptr;
+  char *ptr;
   int save_p_list;
   int start_col;
   colnr_T vc;
@@ -1658,9 +1657,9 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 
     // Advance the cursor until we reach the right screen column.
     last_vcol = 0;
-    ptr = (char_u *)get_cursor_line_ptr();
+    ptr = get_cursor_line_ptr();
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, 0, (char *)ptr, (char *)ptr);
+    init_chartabsize_arg(&cts, curwin, 0, 0, ptr, ptr);
     while (cts.cts_vcol <= (int)curwin->w_virtcol) {
       last_vcol = cts.cts_vcol;
       if (cts.cts_vcol > 0) {
@@ -1683,7 +1682,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
       ptr = xmallocz(i);
       memset(ptr, ' ', i);
       new_cursor_col += (int)i;
-      ins_str((char *)ptr);
+      ins_str(ptr);
       xfree(ptr);
     }
 
@@ -2062,8 +2061,8 @@ void insertchar(int c, int flags, int second_indent)
 
     // Need to remove existing (middle) comment leader and insert end
     // comment leader.  First, check what comment leader we can find.
-    char_u *line = (char_u *)get_cursor_line_ptr();
-    int i = get_leader_len((char *)line, &p, false, true);
+    char *line = get_cursor_line_ptr();
+    int i = get_leader_len(line, &p, false, true);
     if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) {  // Just checking
       // Skip middle-comment string
       while (*p && p[-1] != ':') {  // find end of middle flags
@@ -2308,7 +2307,7 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
   if (did_restart_edit == 0 || (ptr != NULL
                                 && (int)strlen(ptr) > new_insert_skip)) {
     xfree(last_insert);
-    last_insert = (char_u *)ptr;
+    last_insert = ptr;
     last_insert_skip = new_insert_skip;
   } else {
     xfree(ptr);
@@ -2414,7 +2413,7 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
 // Used for the replace command.
 void set_last_insert(int c)
 {
-  char_u *s;
+  char *s;
 
   xfree(last_insert);
   last_insert = xmalloc(MB_MAXBYTES * 3 + 5);
@@ -2423,7 +2422,7 @@ void set_last_insert(int c)
   if (c < ' ' || c == DEL) {
     *s++ = Ctrl_V;
   }
-  s = add_char2buf(c, s);
+  s = (char *)add_char2buf(c, (char_u *)s);
   *s++ = ESC;
   *s++ = NUL;
   last_insert_skip = 0;
@@ -2738,12 +2737,12 @@ char_u *get_last_insert(void)
   if (last_insert == NULL) {
     return NULL;
   }
-  return last_insert + last_insert_skip;
+  return (char_u *)last_insert + last_insert_skip;
 }
 
 // Get last inserted string, and remove trailing <Esc>.
 // Returns pointer to allocated memory (must be freed) or NULL.
-char_u *get_last_insert_save(void)
+char *get_last_insert_save(void)
 {
   char *s;
   int len;
@@ -2751,13 +2750,13 @@ char_u *get_last_insert_save(void)
   if (last_insert == NULL) {
     return NULL;
   }
-  s = xstrdup((char *)last_insert + last_insert_skip);
+  s = xstrdup(last_insert + last_insert_skip);
   len = (int)strlen(s);
   if (len > 0 && s[len - 1] == ESC) {         // remove trailing ESC
     s[len - 1] = NUL;
   }
 
-  return (char_u *)s;
+  return s;
 }
 
 /// Check the word in front of the cursor for an abbreviation.
@@ -4502,7 +4501,7 @@ static bool ins_tab(void)
   if (!curbuf->b_p_et && (tabstop_count(curbuf->b_p_vsts_array) > 0
                           || get_sts_value() > 0
                           || (p_sta && ind))) {
-    char_u *ptr;
+    char *ptr;
     char *saved_line = NULL;         // init for GCC
     pos_T pos;
     pos_T fpos;
@@ -4517,9 +4516,9 @@ static bool ins_tab(void)
       pos = curwin->w_cursor;
       cursor = &pos;
       saved_line = xstrdup(get_cursor_line_ptr());
-      ptr = (char_u *)saved_line + pos.col;
+      ptr = saved_line + pos.col;
     } else {
-      ptr = (char_u *)get_cursor_pos_ptr();
+      ptr = get_cursor_pos_ptr();
       cursor = &curwin->w_cursor;
     }
 
@@ -4547,9 +4546,9 @@ static bool ins_tab(void)
     getvcol(curwin, &fpos, &vcol, NULL, NULL);
     getvcol(curwin, cursor, &want_vcol, NULL, NULL);
 
-    char_u *tab = (char_u *)"\t";
+    char *tab = "\t";
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)tab, (char *)tab);
+    init_chartabsize_arg(&cts, curwin, 0, vcol, tab, tab);
 
     // Use as many TABs as possible.  Beware of 'breakindent', 'showbreak'
     // and 'linebreak' adding extra virtual columns.
@@ -4578,13 +4577,13 @@ static bool ins_tab(void)
     if (change_col >= 0) {
       int repl_off = 0;
       // Skip over the spaces we need.
-      init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)ptr, (char *)ptr);
+      init_chartabsize_arg(&cts, curwin, 0, vcol, ptr, ptr);
       while (cts.cts_vcol < want_vcol && *cts.cts_ptr == ' ') {
         cts.cts_vcol += lbr_chartabsize(&cts);
         cts.cts_ptr++;
         repl_off++;
       }
-      ptr = (char_u *)cts.cts_ptr;
+      ptr = cts.cts_ptr;
       vcol = cts.cts_vcol;
       clear_chartabsize_arg(&cts);
 
@@ -4761,8 +4760,8 @@ static int ins_digraph(void)
 int ins_copychar(linenr_T lnum)
 {
   int c;
-  char_u *ptr, *prev_ptr;
-  char_u *line;
+  char *ptr, *prev_ptr;
+  char *line;
 
   if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) {
     vim_beep(BO_COPY);
@@ -4770,25 +4769,25 @@ int ins_copychar(linenr_T lnum)
   }
 
   // try to advance to the cursor column
-  line = (char_u *)ml_get(lnum);
+  line = ml_get(lnum);
   prev_ptr = line;
   validate_virtcol();
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, curwin, lnum, 0, (char *)line, (char *)line);
+  init_chartabsize_arg(&cts, curwin, lnum, 0, line, line);
   while (cts.cts_vcol < curwin->w_virtcol && *cts.cts_ptr != NUL) {
-    prev_ptr = (char_u *)cts.cts_ptr;
+    prev_ptr = cts.cts_ptr;
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
 
   if (cts.cts_vcol > curwin->w_virtcol) {
     ptr = prev_ptr;
   } else {
-    ptr = (char_u *)cts.cts_ptr;
+    ptr = cts.cts_ptr;
   }
   clear_chartabsize_arg(&cts);
 
-  c = utf_ptr2char((char *)ptr);
+  c = utf_ptr2char(ptr);
   if (c == NUL) {
     vim_beep(BO_COPY);
   }
@@ -4837,7 +4836,7 @@ static int ins_ctrl_ey(int tc)
 static void ins_try_si(int c)
 {
   pos_T *pos, old_pos;
-  char_u *ptr;
+  char *ptr;
   int i;
   bool temp;
 
@@ -4851,7 +4850,7 @@ static void ins_try_si(int c)
       // containing the matching '(' if there is one.  This handles the
       // case where an "if (..\n..) {" statement continues over multiple
       // lines -- webb
-      ptr = (char_u *)ml_get(pos->lnum);
+      ptr = ml_get(pos->lnum);
       i = pos->col;
       if (i > 0) {              // skip blanks before '{'
         while (--i > 0 && ascii_iswhite(ptr[i])) {}
@@ -4876,7 +4875,7 @@ static void ins_try_si(int c)
         old_pos = curwin->w_cursor;
         i = get_indent();
         while (curwin->w_cursor.lnum > 1) {
-          ptr = (char_u *)skipwhite(ml_get(--(curwin->w_cursor.lnum)));
+          ptr = skipwhite(ml_get(--(curwin->w_cursor.lnum)));
 
           // ignore empty lines and lines starting with '#'.
           if (*ptr != '#' && *ptr != NUL) {
@@ -4927,7 +4926,7 @@ colnr_T get_nolist_virtcol(void)
 // "c" is the character that was typed.
 // Return a pointer to allocated memory with the replacement string.
 // Return NULL to continue inserting "c".
-static char_u *do_insert_char_pre(int c)
+static char *do_insert_char_pre(int c)
 {
   char buf[MB_MAXBYTES + 1];
   const int save_State = State;
@@ -4958,7 +4957,7 @@ static char_u *do_insert_char_pre(int c)
   // Restore the State, it may have been changed.
   State = save_State;
 
-  return (char_u *)res;
+  return res;
 }
 
 bool get_can_cindent(void)
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index b0805aecff..9f1a64fef5 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -7408,7 +7408,7 @@ void ex_echo(exarg_T *eap)
 /// ":echohl {name}".
 void ex_echohl(exarg_T *eap)
 {
-  echo_attr = syn_name2attr((char_u *)eap->arg);
+  echo_attr = syn_name2attr(eap->arg);
 }
 
 /// ":execute expr1 ..." execute the result of an expression.
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 25e026706c..648e101fcd 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -7612,7 +7612,7 @@ static void f_spellsuggest(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
     maxcount = 25;
   }
 
-  spell_suggest_list(&ga, (char_u *)str, maxcount, need_capital, false);
+  spell_suggest_list(&ga, (char *)str, maxcount, need_capital, false);
 
 f_spellsuggest_return:
   tv_list_alloc_ret(rettv, (ptrdiff_t)ga.ga_len);
diff --git a/src/nvim/eval/typval_defs.h b/src/nvim/eval/typval_defs.h
index 939e5d0810..4615198441 100644
--- a/src/nvim/eval/typval_defs.h
+++ b/src/nvim/eval/typval_defs.h
@@ -337,7 +337,7 @@ struct ufunc {
                            ///< used for s: variables
   int uf_refcount;      ///< reference count, see func_name_refcount()
   funccall_T *uf_scoped;       ///< l: local variables for closure
-  char_u *uf_name_exp;  ///< if "uf_name[]" starts with SNR the name with
+  char *uf_name_exp;    ///< if "uf_name[]" starts with SNR the name with
                         ///< "<SNR>" as a string, otherwise NULL
   char uf_name[];    ///< Name of function (actual size equals name);
                      ///< can start with <SNR>123_
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 5d3b70b414..41dc7d5e61 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1652,7 +1652,7 @@ theend:
 
 char *printable_func_name(ufunc_T *fp)
 {
-  return fp->uf_name_exp != NULL ? (char *)fp->uf_name_exp : fp->uf_name;
+  return fp->uf_name_exp != NULL ? fp->uf_name_exp : fp->uf_name;
 }
 
 /// List the head of the function: "name(arg1, arg2)".
@@ -2296,7 +2296,7 @@ void ex_function(exarg_T *eap)
     } else {
       xfree(line_to_free);
       if (eap->getline == NULL) {
-        theline = (char *)getcmdline(':', 0L, indent, do_concat);
+        theline = getcmdline(':', 0L, indent, do_concat);
       } else {
         theline = eap->getline(':', eap->cookie, indent, do_concat);
       }
@@ -2532,7 +2532,7 @@ void ex_function(exarg_T *eap)
         fp = NULL;
         overwrite = true;
       } else {
-        char_u *exp_name = fp->uf_name_exp;
+        char *exp_name = fp->uf_name_exp;
         // redefine existing function, keep the expanded name
         XFREE_CLEAR(name);
         fp->uf_name_exp = NULL;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index d4f1169daf..ec2ff652b0 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -919,7 +919,7 @@ static char *get_loop_line(int c, void *cookie, int indent, bool do_concat)
     char *line;
     // First time inside the ":while"/":for": get line normally.
     if (cp->getline == NULL) {
-      line = (char *)getcmdline(c, 0L, indent, do_concat);
+      line = getcmdline(c, 0L, indent, do_concat);
     } else {
       line = cp->getline(c, cp->cookie, indent, do_concat);
     }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 0a1d6b2857..a0a55de729 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -381,7 +381,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
   proftime_T tm;
   int skiplen, patlen;
   char next_char;
-  char_u use_last_pat;
+  bool use_last_pat;
   int search_delim;
 
   // Parsing range may already set the last search pattern.
@@ -725,7 +725,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool clea
   if (ccline.input_fn) {
     s->xpc.xp_context = ccline.xp_context;
     s->xpc.xp_pattern = ccline.cmdbuff;
-    s->xpc.xp_arg = (char *)ccline.xp_arg;
+    s->xpc.xp_arg = ccline.xp_arg;
   }
 
   // Avoid scrolling when called by a recursive do_cmdline(), e.g. when
@@ -908,7 +908,7 @@ theend:
   xfree(ccline.last_colors.cmdbuff);
   kv_destroy(ccline.last_colors.colors);
 
-  char_u *p = (char_u *)ccline.cmdbuff;
+  char *p = ccline.cmdbuff;
 
   if (ui_has(kUICmdline)) {
     ui_call_cmdline_hide(ccline.level);
@@ -923,7 +923,7 @@ theend:
     ccline.cmdbuff = NULL;
   }
 
-  return p;
+  return (uint8_t *)p;
 }
 
 static int command_line_check(VimState *state)
@@ -2625,9 +2625,9 @@ static void abandon_cmdline(void)
 ///
 /// @param count  only used for incremental search
 /// @param indent  indent for inside conditionals
-char_u *getcmdline(int firstc, long count, int indent, bool do_concat FUNC_ATTR_UNUSED)
+char *getcmdline(int firstc, long count, int indent, bool do_concat FUNC_ATTR_UNUSED)
 {
-  return command_line_enter(firstc, count, indent, true);
+  return (char *)command_line_enter(firstc, count, indent, true);
 }
 
 /// Get a command line with a prompt
@@ -2660,10 +2660,10 @@ char *getcmdline_prompt(const int firstc, const char *const prompt, const int at
     CLEAR_FIELD(ccline);
   }
   ccline.prompt_id = last_prompt_id++;
-  ccline.cmdprompt = (char_u *)prompt;
+  ccline.cmdprompt = (char *)prompt;
   ccline.cmdattr = attr;
   ccline.xp_context = xp_context;
-  ccline.xp_arg = (char_u *)xp_arg;
+  ccline.xp_arg = (char *)xp_arg;
   ccline.input_fn = (firstc == '@');
   ccline.highlight_callback = highlight_callback;
 
@@ -2687,12 +2687,6 @@ char *getcmdline_prompt(const int firstc, const char *const prompt, const int at
   return ret;
 }
 
-// Return current cmdline prompt
-char_u *get_cmdprompt(void)
-{
-  return ccline.cmdprompt;
-}
-
 /// Read the 'wildmode' option, fill wim_flags[].
 int check_opt_wim(void)
 {
@@ -2872,7 +2866,7 @@ char *getexline(int c, void *cookie, int indent, bool do_concat)
     (void)vgetc();
   }
 
-  return (char *)getcmdline(c, 1L, indent, do_concat);
+  return getcmdline(c, 1L, indent, do_concat);
 }
 
 bool cmdline_overstrike(void)
@@ -2910,7 +2904,7 @@ void realloc_cmdbuff(int len)
     return;  // no need to resize
   }
 
-  char_u *p = (char_u *)ccline.cmdbuff;
+  char *p = ccline.cmdbuff;
   alloc_cmdbuff(len);                   // will get some more
   // There isn't always a NUL after the command, but it may need to be
   // there, thus copy up to the NUL and add a NUL.
@@ -2922,7 +2916,7 @@ void realloc_cmdbuff(int len)
       && ccline.xpc->xp_pattern != NULL
       && ccline.xpc->xp_context != EXPAND_NOTHING
       && ccline.xpc->xp_context != EXPAND_UNSUCCESSFUL) {
-    int i = (int)((char_u *)ccline.xpc->xp_pattern - p);
+    int i = (int)(ccline.xpc->xp_pattern - p);
 
     // If xp_pattern points inside the old cmdbuff it needs to be adjusted
     // to point into the newly allocated memory.
@@ -3257,10 +3251,10 @@ static void draw_cmdline(int start, int len)
     bool do_arabicshape = false;
     int mb_l;
     for (int i = start; i < start + len; i += mb_l) {
-      char_u *p = (char_u *)ccline.cmdbuff + i;
+      char *p = ccline.cmdbuff + i;
       int u8cc[MAX_MCO];
-      int u8c = utfc_ptr2char_len((char *)p, u8cc, start + len - i);
-      mb_l = utfc_ptr2len_len((char *)p, start + len - i);
+      int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
+      mb_l = utfc_ptr2len_len(p, start + len - i);
       if (ARABIC_CHAR(u8c)) {
         do_arabicshape = true;
         break;
@@ -3293,10 +3287,10 @@ static void draw_cmdline(int start, int len)
     int prev_c = 0;
     int prev_c1 = 0;
     for (int i = start; i < start + len; i += mb_l) {
-      char_u *p = (char_u *)ccline.cmdbuff + i;
+      char *p = ccline.cmdbuff + i;
       int u8cc[MAX_MCO];
-      int u8c = utfc_ptr2char_len((char *)p, u8cc, start + len - i);
-      mb_l = utfc_ptr2len_len((char *)p, start + len - i);
+      int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
+      mb_l = utfc_ptr2len_len(p, start + len - i);
       if (ARABIC_CHAR(u8c)) {
         int pc;
         int pc1 = 0;
@@ -3310,7 +3304,7 @@ static void draw_cmdline(int start, int len)
           if (i + mb_l >= start + len) {
             nc = NUL;
           } else {
-            nc = utf_ptr2char((char *)p + mb_l);
+            nc = utf_ptr2char(p + mb_l);
           }
         } else {
           // Displaying from left to right.
@@ -3319,7 +3313,7 @@ static void draw_cmdline(int start, int len)
           } else {
             int pcc[MAX_MCO];
 
-            pc = utfc_ptr2char_len((char *)p + mb_l, pcc, start + len - i - mb_l);
+            pc = utfc_ptr2char_len(p + mb_l, pcc, start + len - i - mb_l);
             pc1 = pcc[0];
           }
           nc = prev_c;
@@ -3369,7 +3363,7 @@ static void ui_ext_cmdline_show(CmdlineInfo *line)
   if (cmdline_star) {
     content = arena_array(&arena, 1);
     size_t len = 0;
-    for (char_u *p = (char_u *)ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
+    for (char *p = ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
       len++;
     }
     char *buf = arena_alloc(&arena, len, false);
@@ -3400,7 +3394,7 @@ static void ui_ext_cmdline_show(CmdlineInfo *line)
   char charbuf[2] = { (char)line->cmdfirstc, 0 };
   ui_call_cmdline_show(content, line->cmdpos,
                        cstr_as_string(charbuf),
-                       cstr_as_string((char *)(line->cmdprompt)),
+                       cstr_as_string((line->cmdprompt)),
                        line->cmdindent,
                        line->level);
   if (line->special_char) {
@@ -3682,7 +3676,7 @@ static void restore_cmdline(CmdlineInfo *ccp)
 static bool cmdline_paste(int regname, bool literally, bool remcr)
 {
   char *arg;
-  char_u *p;
+  char *p;
   bool allocated;
 
   // check for valid regname; also accept special characters for CTRL-R in
@@ -3714,7 +3708,7 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
 
     // When 'incsearch' is set and CTRL-R CTRL-W used: skip the duplicate
     // part of the word.
-    p = (char_u *)arg;
+    p = arg;
     if (p_is && regname == Ctrl_W) {
       char *w;
       int len;
@@ -3733,7 +3727,7 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
       }
     }
 
-    cmdline_paste_str((char *)p, literally);
+    cmdline_paste_str(p, literally);
     if (allocated) {
       xfree(arg);
     }
@@ -3800,7 +3794,7 @@ static void redrawcmdprompt(void)
     msg_putchar(ccline.cmdfirstc);
   }
   if (ccline.cmdprompt != NULL) {
-    msg_puts_attr((const char *)ccline.cmdprompt, ccline.cmdattr);
+    msg_puts_attr(ccline.cmdprompt, ccline.cmdattr);
     ccline.cmdindent = msg_col + (msg_row - cmdline_row) * Columns;
     // do the reverse of cmd_startcol()
     if (ccline.cmdfirstc != NUL) {
@@ -4018,11 +4012,11 @@ char *vim_strsave_fnameescape(const char *const fname, const int what)
 /// Put a backslash before the file name in "pp", which is in allocated memory.
 void escape_fname(char **pp)
 {
-  char_u *p = xmalloc(strlen(*pp) + 2);
+  char *p = xmalloc(strlen(*pp) + 2);
   p[0] = '\\';
   STRCPY(p + 1, *pp);
   xfree(*pp);
-  *pp = (char *)p;
+  *pp = p;
 }
 
 /// For each file name in files[num_files]:
diff --git a/src/nvim/ex_getln.h b/src/nvim/ex_getln.h
index 916b695a35..61ac4b69c5 100644
--- a/src/nvim/ex_getln.h
+++ b/src/nvim/ex_getln.h
@@ -54,14 +54,14 @@ struct cmdline_info {
   int cmdspos;                  ///< cursor column on screen
   int cmdfirstc;                ///< ':', '/', '?', '=', '>' or NUL
   int cmdindent;                ///< number of spaces before cmdline
-  char_u *cmdprompt;            ///< message in front of cmdline
+  char *cmdprompt;              ///< message in front of cmdline
   int cmdattr;                  ///< attributes for prompt
   int overstrike;               ///< Typing mode on the command line.  Shared by
                                 ///< getcmdline() and put_on_cmdline().
   expand_T *xpc;                ///< struct being used for expansion, xp_pattern
                                 ///< may point into cmdbuff
   int xp_context;               ///< type of expansion
-  char_u *xp_arg;               ///< user-defined expansion arg
+  char *xp_arg;                 ///< user-defined expansion arg
   int input_fn;                 ///< when true Invoked for input() function
   unsigned prompt_id;           ///< Prompt number, used to disable coloring on errors.
   Callback highlight_callback;  ///< Callback used for coloring user input.
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 2a81b4deb0..5f7e41e6e0 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -77,22 +77,20 @@ static int hl_attr_table[] =
 /// The ID of a highlight group is also called group ID.  It is the index in
 /// the highlight_ga array PLUS ONE.
 typedef struct {
-  char_u *sg_name;         ///< highlight group name
-  char *sg_name_u;       ///< uppercase of sg_name
+  char *sg_name;                ///< highlight group name
+  char *sg_name_u;              ///< uppercase of sg_name
   bool sg_cleared;              ///< "hi clear" was used
   int sg_attr;                  ///< Screen attr @see ATTR_ENTRY
   int sg_link;                  ///< link to this highlight group ID
   int sg_deflink;               ///< default link; restored in highlight_clear()
   int sg_set;                   ///< combination of flags in \ref SG_SET
   sctx_T sg_deflink_sctx;       ///< script where the default link was set
-  sctx_T sg_script_ctx;         ///< script in which the group was last set
-  // for terminal UIs
+  sctx_T sg_script_ctx;         ///< script in which the group was last set for terminal UIs
   int sg_cterm;                 ///< "cterm=" highlighting attr
                                 ///< (combination of \ref HlAttrFlags)
   int sg_cterm_fg;              ///< terminal fg color number + 1
   int sg_cterm_bg;              ///< terminal bg color number + 1
-  bool sg_cterm_bold;           ///< bold attr was set for light color
-  // for RGB UIs
+  bool sg_cterm_bold;           ///< bold attr was set for light color for RGB UIs
   int sg_gui;                   ///< "gui=" highlighting attributes
                                 ///< (combination of \ref HlAttrFlags)
   RgbValue sg_rgb_fg;           ///< RGB foreground color
@@ -571,7 +569,7 @@ int highlight_num_groups(void)
 }
 
 /// Returns the name of a highlight group.
-char_u *highlight_group_name(int id)
+char *highlight_group_name(int id)
 {
   return hl_table[id].sg_name;
 }
@@ -658,7 +656,7 @@ void init_highlight(bool both, bool reset)
 /// @return  OK for success, FAIL for failure.
 int load_colors(char *name)
 {
-  char_u *buf;
+  char *buf;
   int retval = FAIL;
   static bool recursive = false;
 
@@ -673,11 +671,11 @@ int load_colors(char *name)
   size_t buflen = strlen(name) + 12;
   buf = xmalloc(buflen);
   apply_autocmds(EVENT_COLORSCHEMEPRE, name, curbuf->b_fname, false, curbuf);
-  snprintf((char *)buf, buflen, "colors/%s.vim", name);
-  retval = source_runtime((char *)buf, DIP_START + DIP_OPT);
+  snprintf(buf, buflen, "colors/%s.vim", name);
+  retval = source_runtime(buf, DIP_START + DIP_OPT);
   if (retval == FAIL) {
-    snprintf((char *)buf, buflen, "colors/%s.lua", name);
-    retval = source_runtime((char *)buf, DIP_START + DIP_OPT);
+    snprintf(buf, buflen, "colors/%s.lua", name);
+    retval = source_runtime(buf, DIP_START + DIP_OPT);
   }
   xfree(buf);
   if (retval == OK) {
@@ -1471,7 +1469,7 @@ static void highlight_list_one(const int id)
   const HlGroup *sgp = &hl_table[id - 1];  // index is ID minus one
   bool didh = false;
 
-  if (message_filtered((char *)sgp->sg_name)) {
+  if (message_filtered(sgp->sg_name)) {
     return;
   }
 
@@ -1505,7 +1503,7 @@ static void highlight_list_one(const int id)
     didh = true;
     msg_puts_attr("links to", HL_ATTR(HLF_D));
     msg_putchar(' ');
-    msg_outtrans((char *)hl_table[hl_table[id - 1].sg_link - 1].sg_name);
+    msg_outtrans(hl_table[hl_table[id - 1].sg_link - 1].sg_name);
   }
 
   if (!didh) {
@@ -1527,7 +1525,7 @@ Dictionary get_global_hl_defs(Arena *arena)
       hlattrs2dict(&attrs, syn_attr2entry(h->sg_attr), true);
     } else if (h->sg_link > 0) {
       attrs = arena_dict(arena, 1);
-      char *link = (char *)hl_table[h->sg_link - 1].sg_name;
+      char *link = hl_table[h->sg_link - 1].sg_name;
       PUT_C(attrs, "link", STRING_OBJ(cstr_as_string(link)));
     }
     PUT_C(rv, (char *)h->sg_name, DICTIONARY_OBJ(attrs));
@@ -1702,7 +1700,7 @@ bool syn_list_header(const bool did_header, const int outlen, const int id, bool
     if (got_int) {
       return true;
     }
-    msg_outtrans((char *)hl_table[id - 1].sg_name);
+    msg_outtrans(hl_table[id - 1].sg_name);
     name_col = msg_col;
     endcol = 15;
   } else if ((ui_has(kUIMessages) || msg_silent) && !force_newline) {
@@ -1804,10 +1802,10 @@ int syn_name2id_len(const char *name, size_t len)
 
 /// Lookup a highlight group name and return its attributes.
 /// Return zero if not found.
-int syn_name2attr(const char_u *name)
+int syn_name2attr(const char *name)
   FUNC_ATTR_NONNULL_ALL
 {
-  int id = syn_name2id((char *)name);
+  int id = syn_name2id(name);
 
   if (id != 0) {
     return syn_id2attr(id);
@@ -1823,10 +1821,10 @@ int highlight_exists(const char *name)
 
 /// Return the name of highlight group "id".
 /// When not a valid ID return an empty string.
-char_u *syn_id2name(int id)
+char *syn_id2name(int id)
 {
   if (id <= 0 || id > highlight_ga.ga_len) {
-    return (char_u *)"";
+    return "";
   }
   return hl_table[id - 1].sg_name;
 }
@@ -1896,7 +1894,7 @@ static int syn_add_group(const char *name, size_t len)
   // Append another syntax_highlight entry.
   HlGroup *hlgp = GA_APPEND_VIA_PTR(HlGroup, &highlight_ga);
   CLEAR_POINTER(hlgp);
-  hlgp->sg_name = (char_u *)arena_memdupz(&highlight_arena, name, len);
+  hlgp->sg_name = arena_memdupz(&highlight_arena, name, len);
   hlgp->sg_rgb_bg = -1;
   hlgp->sg_rgb_fg = -1;
   hlgp->sg_rgb_sp = -1;
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 759920c4ec..10a8195e7a 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -757,7 +757,7 @@ void ml_recover(bool checkext)
     directly = false;
 
     // count the number of matching swap files
-    len = recover_names((char_u *)fname, false, 0, NULL);
+    len = recover_names(fname, false, 0, NULL);
     if (len == 0) {                 // no swap files found
       semsg(_("E305: No swap file found for %s"), fname);
       goto theend;
@@ -767,7 +767,7 @@ void ml_recover(bool checkext)
       i = 1;
     } else {                          // several swap files found, choose
       // list the names of the swap files
-      (void)recover_names((char_u *)fname, true, 0, NULL);
+      (void)recover_names(fname, true, 0, NULL);
       msg_putchar('\n');
       msg_puts(_("Enter number of swap file to use (0 to quit): "));
       i = get_number(false, NULL);
@@ -776,7 +776,7 @@ void ml_recover(bool checkext)
       }
     }
     // get the swap file name that will be used
-    (void)recover_names((char_u *)fname, false, i, &fname_used);
+    (void)recover_names(fname, false, i, &fname_used);
   }
   if (fname_used == NULL) {
     goto theend;  // user chose invalid number.
@@ -1201,24 +1201,24 @@ theend:
 /// @param list  when true, list the swap file names
 /// @param nr  when non-zero, return nr'th swap file name
 /// @param fname_out  result when "nr" > 0
-int recover_names(char_u *fname, int list, int nr, char **fname_out)
+int recover_names(char *fname, int list, int nr, char **fname_out)
 {
   int num_names;
   char *(names[6]);
-  char_u *tail;
+  char *tail;
   char *p;
   int file_count = 0;
   char **files;
-  char_u *fname_res = NULL;
+  char *fname_res = NULL;
 #ifdef HAVE_READLINK
-  char_u fname_buf[MAXPATHL];
+  char fname_buf[MAXPATHL];
 #endif
 
   if (fname != NULL) {
 #ifdef HAVE_READLINK
     // Expand symlink in the file name, because the swap file is created
     // with the actual file instead of with the symlink.
-    if (resolve_symlink((char *)fname, (char *)fname_buf) == OK) {
+    if (resolve_symlink(fname, fname_buf) == OK) {
       fname_res = fname_buf;
     } else
 #endif
@@ -1250,7 +1250,7 @@ int recover_names(char_u *fname, int list, int nr, char **fname_out)
         names[2] = xstrdup(".sw?");
         num_names = 3;
       } else {
-        num_names = recov_file_names(names, (char *)fname_res, true);
+        num_names = recov_file_names(names, fname_res, true);
       }
     } else {                      // check directory dir_name
       if (fname == NULL) {
@@ -1267,13 +1267,12 @@ int recover_names(char_u *fname, int list, int nr, char **fname_out)
             && len > 1
             && p[-1] == p[-2]) {
           // Ends with '//', Use Full path for swap name
-          tail = (char_u *)make_percent_swname(dir_name,
-                                               (char *)fname_res);
+          tail = make_percent_swname(dir_name, fname_res);
         } else {
-          tail = (char_u *)path_tail((char *)fname_res);
-          tail = (char_u *)concat_fnames(dir_name, (char *)tail, true);
+          tail = path_tail(fname_res);
+          tail = concat_fnames(dir_name, tail, true);
         }
-        num_names = recov_file_names(names, (char *)tail, false);
+        num_names = recov_file_names(names, tail, false);
         xfree(tail);
       }
     }
@@ -1290,11 +1289,11 @@ int recover_names(char_u *fname, int list, int nr, char **fname_out)
     // not able to execute the shell).
     // Try finding a swap file by simply adding ".swp" to the file name.
     if (*dirp == NUL && file_count + num_files == 0 && fname != NULL) {
-      char_u *swapname = (char_u *)modname((char *)fname_res, ".swp", true);
+      char *swapname = modname(fname_res, ".swp", true);
       if (swapname != NULL) {
-        if (os_path_exists((char *)swapname)) {
-          files = xmalloc(sizeof(char_u *));
-          files[0] = (char *)swapname;
+        if (os_path_exists(swapname)) {
+          files = xmalloc(sizeof(char *));
+          files[0] = swapname;
           swapname = NULL;
           num_files = 1;
         }
@@ -1877,7 +1876,7 @@ int ml_append(linenr_T lnum, char *line, colnr_T len, bool newfile)
 /// @param line  text of the new line
 /// @param len  length of new line, including NUL, or 0
 /// @param newfile  flag, see above
-int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, bool newfile)
+int ml_append_buf(buf_T *buf, linenr_T lnum, char *line, colnr_T len, bool newfile)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   if (buf->b_ml.ml_mfp == NULL) {
@@ -1887,7 +1886,7 @@ int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, bool new
   if (buf->b_ml.ml_line_lnum != 0) {
     ml_flush_line(buf);
   }
-  return ml_append_int(buf, lnum, (char *)line, len, newfile, false);
+  return ml_append_int(buf, lnum, line, len, newfile, false);
 }
 
 /// @param lnum  append after this line (can be 0)
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 6fb00ca6b5..ad2bcbc790 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -3998,7 +3998,7 @@ static void nv_search(cmdarg_T *cap)
 
   // When using 'incsearch' the cursor may be moved to set a different search
   // start position.
-  cap->searchbuf = (char *)getcmdline(cap->cmdchar, cap->count1, 0, true);
+  cap->searchbuf = getcmdline(cap->cmdchar, cap->count1, 0, true);
 
   if (cap->searchbuf == NULL) {
     clearop(oap);
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 42ff2b15ed..dfaf12b357 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -723,7 +723,7 @@ int get_expr_register(void)
 {
   char *new_line;
 
-  new_line = (char *)getcmdline('=', 0L, 0, true);
+  new_line = getcmdline('=', 0L, 0, true);
   if (new_line == NULL) {
     return NUL;
   }
@@ -1131,7 +1131,7 @@ int do_execreg(int regname, int colon, int addcr, int silent)
     retval = put_in_typebuf(p, true, colon, silent);
     xfree(p);
   } else if (regname == '.') {        // use last inserted text
-    p = (char *)get_last_insert_save();
+    p = get_last_insert_save();
     if (p == NULL) {
       emsg(_(e_noinstext));
       return FAIL;
@@ -1351,7 +1351,7 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
     return true;
 
   case '.':                     // last inserted text
-    *argp = (char *)get_last_insert_save();
+    *argp = get_last_insert_save();
     *allocated = true;
     if (*argp == NULL && errmsg) {
       emsg(_(e_noinstext));
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 32ae0fc276..f0c1011844 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -3168,15 +3168,15 @@ void qf_list(exarg_T *eap)
 
   // Get the attributes for the different quickfix highlight items.  Note
   // that this depends on syntax items defined in the qf.vim syntax file
-  qfFileAttr = syn_name2attr((char_u *)"qfFileName");
+  qfFileAttr = syn_name2attr("qfFileName");
   if (qfFileAttr == 0) {
     qfFileAttr = HL_ATTR(HLF_D);
   }
-  qfSepAttr = syn_name2attr((char_u *)"qfSeparator");
+  qfSepAttr = syn_name2attr("qfSeparator");
   if (qfSepAttr == 0) {
     qfSepAttr = HL_ATTR(HLF_D);
   }
-  qfLineAttr = syn_name2attr((char_u *)"qfLineNr");
+  qfLineAttr = syn_name2attr("qfLineNr");
   if (qfLineAttr == 0) {
     qfLineAttr = HL_ATTR(HLF_N);
   }
@@ -3997,7 +3997,7 @@ static int qf_buf_add_line(qf_list_T *qfl, buf_T *buf, linenr_T lnum, const qfli
                 IObuff + len, IOSIZE - len);
   }
 
-  if (ml_append_buf(buf, lnum, (char_u *)IObuff,
+  if (ml_append_buf(buf, lnum, IObuff,
                     (colnr_T)strlen(IObuff) + 1, false) == FAIL) {
     return FAIL;
   }
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 321023bce2..fd32209310 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -104,7 +104,7 @@ estack_T *estack_push(etype_T type, char *name, linenr_T lnum)
 void estack_push_ufunc(ufunc_T *ufunc, linenr_T lnum)
 {
   estack_T *entry = estack_push(ETYPE_UFUNC,
-                                ufunc->uf_name_exp != NULL ? (char *)ufunc->uf_name_exp : ufunc->uf_name,
+                                ufunc->uf_name_exp != NULL ? ufunc->uf_name_exp : ufunc->uf_name,
                                 lnum);
   if (entry != NULL) {
     entry->es_info.ufunc = ufunc;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index c17fafd3d7..6f2c56f3b1 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -123,7 +123,7 @@ enum {
 slang_T *first_lang = NULL;
 
 // file used for "zG" and "zW"
-char_u *int_wordlist = NULL;
+char *int_wordlist = NULL;
 
 // Structure to store info for word matching.
 typedef struct matchinf_S {
@@ -131,9 +131,9 @@ typedef struct matchinf_S {
 
   // pointers to original text to be checked
   char *mi_word;                   // start of word being checked
-  char_u *mi_end;                  // end of matching word so far
-  char_u *mi_fend;                 // next char to be added to mi_fword
-  char_u *mi_cend;                 // char after what was used for
+  char *mi_end;                    // end of matching word so far
+  char *mi_fend;                   // next char to be added to mi_fword
+  char *mi_cend;                   // char after what was used for
                                    // mi_capflags
 
   // case-folded text
@@ -161,12 +161,12 @@ typedef struct matchinf_S {
 
   // for NOBREAK
   int mi_result2;                       // "mi_result" without following word
-  char_u *mi_end2;                 // "mi_end" without following word
+  char *mi_end2;                        // "mi_end" without following word
 } matchinf_T;
 
 // Structure used for the cookie argument of do_in_runtimepath().
 typedef struct spelload_S {
-  char_u sl_lang[MAXWLEN + 1];          // language name
+  char sl_lang[MAXWLEN + 1];            // language name
   slang_T *sl_slang;                    // resulting slang_T struct
   int sl_nobreak;                       // NOBREAK language found
 } spelload_T;
@@ -242,23 +242,23 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
   // julifeest".
   if (*ptr >= '0' && *ptr <= '9') {
     if (*ptr == '0' && (ptr[1] == 'b' || ptr[1] == 'B')) {
-      mi.mi_end = (char_u *)skipbin(ptr + 2);
+      mi.mi_end = (char *)skipbin(ptr + 2);
     } else if (*ptr == '0' && (ptr[1] == 'x' || ptr[1] == 'X')) {
-      mi.mi_end = (char_u *)skiphex(ptr + 2);
+      mi.mi_end = skiphex(ptr + 2);
     } else {
-      mi.mi_end = (char_u *)skipdigits(ptr);
+      mi.mi_end = skipdigits(ptr);
     }
-    nrlen = (size_t)(mi.mi_end - (char_u *)ptr);
+    nrlen = (size_t)(mi.mi_end - ptr);
   }
 
   // Find the normal end of the word (until the next non-word character).
   mi.mi_word = ptr;
-  mi.mi_fend = (char_u *)ptr;
+  mi.mi_fend = ptr;
   if (spell_iswordp(mi.mi_fend, wp)) {
     bool this_upper = false;  // init for gcc
 
     if (use_camel_case) {
-      int c = utf_ptr2char((char *)mi.mi_fend);
+      int c = utf_ptr2char(mi.mi_fend);
       this_upper = SPELL_ISUPPER(c);
     }
 
@@ -266,7 +266,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
       MB_PTR_ADV(mi.mi_fend);
       if (use_camel_case) {
         const bool prev_upper = this_upper;
-        int c = utf_ptr2char((char *)mi.mi_fend);
+        int c = utf_ptr2char(mi.mi_fend);
         this_upper = SPELL_ISUPPER(c);
         camel_case = !prev_upper && this_upper;
       }
@@ -277,7 +277,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
       // Check word starting with capital letter.
       int c = utf_ptr2char(ptr);
       if (!SPELL_ISUPPER(c)) {
-        wrongcaplen = (size_t)(mi.mi_fend - (char_u *)ptr);
+        wrongcaplen = (size_t)(mi.mi_fend - ptr);
       }
     }
   }
@@ -300,7 +300,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
     MB_PTR_ADV(mi.mi_fend);
   }
 
-  (void)spell_casefold(wp, (char_u *)ptr, (int)(mi.mi_fend - (char_u *)ptr), (char_u *)mi.mi_fword,
+  (void)spell_casefold(wp, ptr, (int)(mi.mi_fend - ptr), mi.mi_fword,
                        MAXWLEN + 1);
   mi.mi_fwordlen = (int)strlen(mi.mi_fword);
 
@@ -345,7 +345,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
     // Count the word in the first language where it's found to be OK.
     if (count_word && mi.mi_result == SP_OK) {
       count_common_word(mi.mi_lp->lp_slang, ptr,
-                        (int)(mi.mi_end - (char_u *)ptr), 1);
+                        (int)(mi.mi_end - ptr), 1);
       count_word = false;
     }
   }
@@ -357,7 +357,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
       if (mi.mi_result == SP_BAD || mi.mi_result == SP_BANNED) {
         return nrlen;
       }
-    } else if (!spell_iswordp_nmw((char_u *)ptr, wp)) {
+    } else if (!spell_iswordp_nmw(ptr, wp)) {
       // When we are at a non-word character there is no error, just
       // skip over the character (try looking for a word after it).
       if (capcol != NULL && wp->w_s->b_cap_prog != NULL) {
@@ -374,28 +374,28 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
       }
 
       return (size_t)(utfc_ptr2len(ptr));
-    } else if (mi.mi_end == (char_u *)ptr) {
+    } else if (mi.mi_end == ptr) {
       // Always include at least one character.  Required for when there
       // is a mixup in "midword".
       MB_PTR_ADV(mi.mi_end);
     } else if (mi.mi_result == SP_BAD
                && LANGP_ENTRY(wp->w_s->b_langp, 0)->lp_slang->sl_nobreak) {
-      char_u *p, *fp;
+      char *p, *fp;
       int save_result = mi.mi_result;
 
       // First language in 'spelllang' is NOBREAK.  Find first position
       // at which any word would be valid.
       mi.mi_lp = LANGP_ENTRY(wp->w_s->b_langp, 0);
       if (mi.mi_lp->lp_slang->sl_fidxs != NULL) {
-        p = (char_u *)mi.mi_word;
-        fp = (char_u *)mi.mi_fword;
+        p = mi.mi_word;
+        fp = mi.mi_fword;
         for (;;) {
           MB_PTR_ADV(p);
           MB_PTR_ADV(fp);
           if (p >= mi.mi_end) {
             break;
           }
-          mi.mi_compoff = (int)(fp - (char_u *)mi.mi_fword);
+          mi.mi_compoff = (int)(fp - mi.mi_fword);
           find_word(&mi, FIND_COMPOUND);
           if (mi.mi_result != SP_BAD) {
             mi.mi_end = p;
@@ -421,7 +421,7 @@ size_t spell_check(win_T *wp, char *ptr, hlf_T *attrp, int *capcol, bool docount
     return wrongcaplen;
   }
 
-  return (size_t)(mi.mi_end - (char_u *)ptr);
+  return (size_t)(mi.mi_end - ptr);
 }
 
 // Check if the word at "mip->mi_word" is in the tree.
@@ -444,7 +444,7 @@ static void find_word(matchinf_T *mip, int mode)
     // Check for word with matching case in keep-case tree.
     ptr = mip->mi_word;
     flen = 9999;                    // no case folding, always enough bytes
-    byts = slang->sl_kbyts;
+    byts = (char_u *)slang->sl_kbyts;
     idxs = slang->sl_kidxs;
 
     if (mode == FIND_KEEPCOMPOUND) {
@@ -455,7 +455,7 @@ static void find_word(matchinf_T *mip, int mode)
     // Check for case-folded in case-folded tree.
     ptr = mip->mi_fword;
     flen = mip->mi_fwordlen;        // available case-folded bytes
-    byts = slang->sl_fbyts;
+    byts = (char_u *)slang->sl_fbyts;
     idxs = slang->sl_fidxs;
 
     if (mode == FIND_PREFIX) {
@@ -575,7 +575,7 @@ static void find_word(matchinf_T *mip, int mode)
     if (utf_head_off(ptr, ptr + wlen) > 0) {
       continue;             // not at first byte of character
     }
-    if (spell_iswordp((char_u *)ptr + wlen, mip->mi_win)) {
+    if (spell_iswordp(ptr + wlen, mip->mi_win)) {
       if (slang->sl_compprog == NULL && !slang->sl_nobreak) {
         continue;                   // next char is a word character
       }
@@ -612,11 +612,11 @@ static void find_word(matchinf_T *mip, int mode)
       // For keep-case tree the case is always right.  For prefixes we
       // don't bother to check.
       if (mode == FIND_FOLDWORD) {
-        if (mip->mi_cend != (char_u *)mip->mi_word + wlen) {
+        if (mip->mi_cend != mip->mi_word + wlen) {
           // mi_capflags was set for a different word length, need
           // to do it again.
-          mip->mi_cend = (char_u *)mip->mi_word + wlen;
-          mip->mi_capflags = captype((char_u *)mip->mi_word, mip->mi_cend);
+          mip->mi_cend = mip->mi_word + wlen;
+          mip->mi_capflags = captype(mip->mi_word, mip->mi_cend);
         }
 
         if (mip->mi_capflags == WF_KEEPCAP
@@ -629,7 +629,7 @@ static void find_word(matchinf_T *mip, int mode)
         // mip->mi_prefarridx that find_prefix() filled.
         c = valid_word_prefix(mip->mi_prefcnt, mip->mi_prefarridx,
                               (int)flags,
-                              (char_u *)mip->mi_word + mip->mi_cprefixlen, slang,
+                              mip->mi_word + mip->mi_cprefixlen, slang,
                               false);
         if (c == 0) {
           continue;
@@ -712,7 +712,7 @@ static void find_word(matchinf_T *mip, int mode)
           } else {
             p = mip->mi_word + mip->mi_compoff;
           }
-          capflags = captype((char_u *)p, (char_u *)mip->mi_word + wlen);
+          capflags = captype(p, mip->mi_word + wlen);
           if (capflags == WF_KEEPCAP || (capflags == WF_ALLCAP
                                          && (flags & WF_FIXCAP) != 0)) {
             continue;
@@ -724,7 +724,7 @@ static void find_word(matchinf_T *mip, int mode)
             // accept a no-caps word, even when the dictionary
             // word specifies ONECAP.
             MB_PTR_BACK(mip->mi_word, p);
-            if (spell_iswordp_nmw((char_u *)p, mip->mi_win)
+            if (spell_iswordp_nmw(p, mip->mi_win)
                 ? capflags == WF_ONECAP
                 : (flags & WF_ONECAP) != 0
                 && capflags != WF_ONECAP) {
@@ -744,12 +744,12 @@ static void find_word(matchinf_T *mip, int mode)
           if (slang->sl_compsylmax < MAXWLEN) {
             // "fword" is only needed for checking syllables.
             if (ptr == mip->mi_word) {
-              (void)spell_casefold(mip->mi_win, (char_u *)ptr, wlen, (char_u *)fword, MAXWLEN);
+              (void)spell_casefold(mip->mi_win, ptr, wlen, fword, MAXWLEN);
             } else {
               xstrlcpy(fword, ptr, (size_t)endlen[endidxcnt] + 1);
             }
           }
-          if (!can_compound(slang, (char *)fword, mip->mi_compflags)) {
+          if (!can_compound(slang, fword, mip->mi_compflags)) {
             continue;
           }
         } else if (slang->sl_comprules != NULL
@@ -767,7 +767,7 @@ static void find_word(matchinf_T *mip, int mode)
 
       if (!word_ends) {
         int save_result = mip->mi_result;
-        char_u *save_end = mip->mi_end;
+        char *save_end = mip->mi_end;
         langp_T *save_lp = mip->mi_lp;
 
         // Check that a valid word follows.  If there is one and we
@@ -878,16 +878,16 @@ static void find_word(matchinf_T *mip, int mode)
       if (nobreak_result == SP_BAD) {
         if (mip->mi_result2 > res) {
           mip->mi_result2 = res;
-          mip->mi_end2 = (char_u *)mip->mi_word + wlen;
+          mip->mi_end2 = mip->mi_word + wlen;
         } else if (mip->mi_result2 == res
-                   && mip->mi_end2 < (char_u *)mip->mi_word + wlen) {
-          mip->mi_end2 = (char_u *)mip->mi_word + wlen;
+                   && mip->mi_end2 < mip->mi_word + wlen) {
+          mip->mi_end2 = mip->mi_word + wlen;
         }
       } else if (mip->mi_result > res) {
         mip->mi_result = res;
-        mip->mi_end = (char_u *)mip->mi_word + wlen;
-      } else if (mip->mi_result == res && mip->mi_end < (char_u *)mip->mi_word + wlen) {
-        mip->mi_end = (char_u *)mip->mi_word + wlen;
+        mip->mi_end = mip->mi_word + wlen;
+      } else if (mip->mi_result == res && mip->mi_end < mip->mi_word + wlen) {
+        mip->mi_end = mip->mi_word + wlen;
       }
 
       if (mip->mi_result == SP_OK) {
@@ -930,19 +930,19 @@ bool match_checkcompoundpattern(char *ptr, int wlen, garray_T *gap)
 bool can_compound(slang_T *slang, const char *word, const uint8_t *flags)
   FUNC_ATTR_NONNULL_ALL
 {
-  char_u uflags[MAXWLEN * 2] = { 0 };
+  char uflags[MAXWLEN * 2] = { 0 };
 
   if (slang->sl_compprog == NULL) {
     return false;
   }
   // Need to convert the single byte flags to utf8 characters.
-  char_u *p = uflags;
+  char *p = uflags;
   for (int i = 0; flags[i] != NUL; i++) {
-    p += utf_char2bytes(flags[i], (char *)p);
+    p += utf_char2bytes(flags[i], p);
   }
   *p = NUL;
   p = uflags;
-  if (!vim_regexec_prog(&slang->sl_compprog, false, p, 0)) {
+  if (!vim_regexec_prog(&slang->sl_compprog, false, (char_u *)p, 0)) {
     return false;
   }
 
@@ -950,7 +950,7 @@ bool can_compound(slang_T *slang, const char *word, const uint8_t *flags)
   // are too many syllables AND the number of compound words is above
   // COMPOUNDWORDMAX then compounding is not allowed.
   if (slang->sl_compsylmax < MAXWLEN
-      && count_syllables(slang, (char_u *)word) > slang->sl_compsylmax) {
+      && count_syllables(slang, word) > slang->sl_compsylmax) {
     return (int)strlen((char *)flags) < slang->sl_compmax;
   }
   return true;
@@ -963,7 +963,7 @@ bool can_compound(slang_T *slang, const char *word, const uint8_t *flags)
 bool match_compoundrule(slang_T *slang, const char_u *compflags)
 {
   // loop over all the COMPOUNDRULE entries
-  for (char_u *p = slang->sl_comprules; *p != NUL; p++) {
+  for (char_u *p = (char_u *)slang->sl_comprules; *p != NUL; p++) {
     // loop over the flags in the compound word we have made, match
     // them against the current rule entry
     for (int i = 0;; i++) {
@@ -1013,7 +1013,7 @@ bool match_compoundrule(slang_T *slang, const char_u *compflags)
 /// @param totprefcnt  nr of prefix IDs
 /// @param arridx  idx in sl_pidxs[]
 /// @param cond_req  only use prefixes with a condition
-int valid_word_prefix(int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang,
+int valid_word_prefix(int totprefcnt, int arridx, int flags, char *word, slang_T *slang,
                       bool cond_req)
 {
   int prefid = (int)((unsigned)flags >> 24);
@@ -1035,7 +1035,7 @@ int valid_word_prefix(int totprefcnt, int arridx, int flags, char_u *word, slang
     // 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, word, 0)) {
+      if (!vim_regexec_prog(rp, false, (char_u *)word, 0)) {
         continue;
       }
     } else if (cond_req) {
@@ -1061,7 +1061,7 @@ static void find_prefix(matchinf_T *mip, int mode)
   int wlen = 0;
   slang_T *slang = mip->mi_lp->lp_slang;
 
-  char_u *byts = slang->sl_pbyts;
+  char_u *byts = (char_u *)slang->sl_pbyts;
   if (byts == NULL) {
     return;                     // array is empty
   }
@@ -1110,8 +1110,8 @@ static void find_prefix(matchinf_T *mip, int mode)
       }
 
       // Case-folded length may differ from original length.
-      mip->mi_cprefixlen = nofold_len((char_u *)mip->mi_fword, mip->mi_prefixlen,
-                                      (char_u *)mip->mi_word);
+      mip->mi_cprefixlen = nofold_len(mip->mi_fword, mip->mi_prefixlen,
+                                      mip->mi_word);
       find_word(mip, FIND_PREFIX);
 
       if (len == 0) {
@@ -1157,7 +1157,7 @@ static void find_prefix(matchinf_T *mip, int mode)
 // Return the length of the folded chars in bytes.
 static int fold_more(matchinf_T *mip)
 {
-  char_u *p = mip->mi_fend;
+  char *p = mip->mi_fend;
   do {
     MB_PTR_ADV(mip->mi_fend);
   } while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend, mip->mi_win));
@@ -1168,7 +1168,7 @@ static int fold_more(matchinf_T *mip)
   }
 
   (void)spell_casefold(mip->mi_win, p, (int)(mip->mi_fend - p),
-                       (char_u *)mip->mi_fword + mip->mi_fwordlen,
+                       mip->mi_fword + mip->mi_fwordlen,
                        MAXWLEN - mip->mi_fwordlen);
   int flen = (int)strlen(mip->mi_fword + mip->mi_fwordlen);
   mip->mi_fwordlen += flen;
@@ -1500,7 +1500,7 @@ void spell_cat_line(char *buf, char *line, int maxlen)
 
 // Load word list(s) for "lang" from Vim spell file(s).
 // "lang" must be the language without the region: e.g., "en".
-static void spell_load_lang(char_u *lang)
+static void spell_load_lang(char *lang)
 {
   char fname_enc[85];
   int r;
@@ -1520,18 +1520,18 @@ static void spell_load_lang(char_u *lang)
   // autocommand may load it then.
   for (int round = 1; round <= 2; round++) {
     // Find the first spell file for "lang" in 'runtimepath' and load it.
-    vim_snprintf((char *)fname_enc, sizeof(fname_enc) - 5,
+    vim_snprintf(fname_enc, sizeof(fname_enc) - 5,
                  "spell/%s.%s.spl", lang, spell_enc());
-    r = do_in_runtimepath((char *)fname_enc, 0, spell_load_cb, &sl);
+    r = do_in_runtimepath(fname_enc, 0, spell_load_cb, &sl);
 
     if (r == FAIL && *sl.sl_lang != NUL) {
       // Try loading the ASCII version.
-      vim_snprintf((char *)fname_enc, sizeof(fname_enc) - 5,
+      vim_snprintf(fname_enc, sizeof(fname_enc) - 5,
                    "spell/%s.ascii.spl", lang);
-      r = do_in_runtimepath((char *)fname_enc, 0, spell_load_cb, &sl);
+      r = do_in_runtimepath(fname_enc, 0, spell_load_cb, &sl);
 
       if (r == FAIL && *sl.sl_lang != NUL && round == 1
-          && apply_autocmds(EVENT_SPELLFILEMISSING, (char *)lang,
+          && apply_autocmds(EVENT_SPELLFILEMISSING, lang,
                             curbuf->b_fname, false, curbuf)) {
         continue;
       }
@@ -1556,7 +1556,7 @@ static void spell_load_lang(char_u *lang)
   } else if (sl.sl_slang != NULL) {
     // At least one file was loaded, now load ALL the additions.
     STRCPY(fname_enc + strlen(fname_enc) - 3, "add.spl");
-    do_in_runtimepath((char *)fname_enc, DIP_ALL, spell_load_cb, &sl);
+    do_in_runtimepath(fname_enc, DIP_ALL, spell_load_cb, &sl);
   }
 
   curbuf->b_locked--;
@@ -1564,19 +1564,19 @@ static void spell_load_lang(char_u *lang)
 
 // Return the encoding used for spell checking: Use 'encoding', except that we
 // use "latin1" for "latin9".  And limit to 60 characters (just in case).
-char_u *spell_enc(void)
+char *spell_enc(void)
 {
   if (strlen(p_enc) < 60 && strcmp(p_enc, "iso-8859-15") != 0) {
-    return (char_u *)p_enc;
+    return p_enc;
   }
-  return (char_u *)"latin1";
+  return "latin1";
 }
 
 // Get the name of the .spl file for the internal wordlist into
 // "fname[MAXPATHL]".
-static void int_wordlist_spl(char_u *fname)
+static void int_wordlist_spl(char *fname)
 {
-  vim_snprintf((char *)fname, MAXPATHL, SPL_FNAME_TMPL,
+  vim_snprintf(fname, MAXPATHL, SPL_FNAME_TMPL,
                int_wordlist, spell_enc());
 }
 
@@ -1700,7 +1700,7 @@ void slang_clear_sug(slang_T *lp)
 static void spell_load_cb(char *fname, void *cookie)
 {
   spelload_T *slp = (spelload_T *)cookie;
-  slang_T *slang = spell_load_file(fname, (char *)slp->sl_lang, NULL, false);
+  slang_T *slang = spell_load_file(fname, slp->sl_lang, NULL, false);
   if (slang != NULL) {
     // When a previously loaded file has NOBREAK also use it for the
     // ".add" files.
@@ -1755,9 +1755,9 @@ void count_common_word(slang_T *lp, char *word, int len, uint8_t count)
 
 // Returns true if byte "n" appears in "str".
 // Like strchr() but independent of locale.
-bool byte_in_str(char_u *str, int n)
+bool byte_in_str(uint8_t *str, int n)
 {
-  for (char_u *p = str; *p != NUL; p++) {
+  for (uint8_t *p = str; *p != NUL; p++) {
     if (*p == n) {
       return true;
     }
@@ -1798,7 +1798,7 @@ int init_syl_tab(slang_T *slang)
 // Count the number of syllables in "word".
 // When "word" contains spaces the syllables after the last space are counted.
 // Returns zero if syllables are not defines.
-static int count_syllables(slang_T *slang, const char_u *word)
+static int count_syllables(slang_T *slang, const char *word)
   FUNC_ATTR_NONNULL_ALL
 {
   int cnt = 0;
@@ -1809,7 +1809,7 @@ static int count_syllables(slang_T *slang, const char_u *word)
     return 0;
   }
 
-  for (const char *p = (char *)word; *p != NUL; p += len) {
+  for (const char *p = word; *p != NUL; p += len) {
     // When running into a space reset counter.
     if (*p == ' ') {
       len = 1;
@@ -1893,11 +1893,11 @@ char *did_set_spelllang(win_T *wp)
   // Loop over comma separated language names.
   for (splp = spl_copy; *splp != NUL;) {
     // Get one language name.
-    copy_option_part(&splp, (char *)lang, MAXWLEN, ",");
+    copy_option_part(&splp, lang, MAXWLEN, ",");
     region = NULL;
     len = (int)strlen(lang);
 
-    if (!valid_spelllang((char *)lang)) {
+    if (!valid_spelllang(lang)) {
       continue;
     }
 
@@ -1913,7 +1913,7 @@ char *did_set_spelllang(win_T *wp)
       filename = true;
 
       // Locate a region and remove it from the file name.
-      p = vim_strchr(path_tail((char *)lang), '_');
+      p = vim_strchr(path_tail(lang), '_');
       if (p != NULL && ASCII_ISALPHA(p[1]) && ASCII_ISALPHA(p[2])
           && !ASCII_ISALPHA(p[3])) {
         xstrlcpy(region_cp, p + 1, 3);
@@ -1925,7 +1925,7 @@ char *did_set_spelllang(win_T *wp)
 
       // Check if we loaded this language before.
       for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-        if (path_full_compare((char *)lang, slang->sl_fname, false, true)
+        if (path_full_compare(lang, slang->sl_fname, false, true)
             == kEqualFiles) {
           break;
         }
@@ -1959,9 +1959,9 @@ char *did_set_spelllang(win_T *wp)
     // If not found try loading the language now.
     if (slang == NULL) {
       if (filename) {
-        (void)spell_load_file((char *)lang, (char *)lang, NULL, false);
+        (void)spell_load_file(lang, lang, NULL, false);
       } else {
-        spell_load_lang((char_u *)lang);
+        spell_load_lang(lang);
         // SpellFileMissing autocommands may do anything, including
         // destroying the buffer we are using or closing the window.
         if (!bufref_valid(&bufref) || !win_valid_any_tab(wp)) {
@@ -1974,12 +1974,12 @@ char *did_set_spelllang(win_T *wp)
     // Loop over the languages, there can be several files for "lang".
     for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
       if (filename
-          ? path_full_compare((char *)lang, slang->sl_fname, false, true) == kEqualFiles
+          ? path_full_compare(lang, slang->sl_fname, false, true) == kEqualFiles
           : STRICMP(lang, slang->sl_name) == 0) {
         region_mask = REGION_ALL;
         if (!filename && region != NULL) {
           // find region in sl_regions
-          c = find_region(slang->sl_regions, (char_u *)region);
+          c = find_region(slang->sl_regions, region);
           if (c == REGION_ALL) {
             if (slang->sl_add) {
               if (*slang->sl_regions != NUL) {
@@ -2022,17 +2022,17 @@ char *did_set_spelllang(win_T *wp)
       if (int_wordlist == NULL) {
         continue;
       }
-      int_wordlist_spl((char_u *)spf_name);
+      int_wordlist_spl(spf_name);
     } else {
       // One entry in 'spellfile'.
-      copy_option_part(&spf, (char *)spf_name, MAXPATHL - 5, ",");
+      copy_option_part(&spf, spf_name, MAXPATHL - 5, ",");
       STRCAT(spf_name, ".spl");
 
       // If it was already found above then skip it.
       for (c = 0; c < ga.ga_len; c++) {
         p = LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
         if (p != NULL
-            && path_full_compare((char *)spf_name, p, false, true) == kEqualFiles) {
+            && path_full_compare(spf_name, p, false, true) == kEqualFiles) {
           break;
         }
       }
@@ -2043,7 +2043,7 @@ char *did_set_spelllang(win_T *wp)
 
     // Check if it was loaded already.
     for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-      if (path_full_compare((char *)spf_name, slang->sl_fname, false, true)
+      if (path_full_compare(spf_name, slang->sl_fname, false, true)
           == kEqualFiles) {
         break;
       }
@@ -2055,13 +2055,13 @@ char *did_set_spelllang(win_T *wp)
       if (round == 0) {
         STRCPY(lang, "internal wordlist");
       } else {
-        xstrlcpy(lang, path_tail((char *)spf_name), MAXWLEN + 1);
-        p = vim_strchr((char *)lang, '.');
+        xstrlcpy(lang, path_tail(spf_name), MAXWLEN + 1);
+        p = vim_strchr(lang, '.');
         if (p != NULL) {
           *p = NUL;             // truncate at ".encoding.add"
         }
       }
-      slang = spell_load_file((char *)spf_name, (char *)lang, NULL, true);
+      slang = spell_load_file(spf_name, lang, NULL, true);
 
       // If one of the languages has NOBREAK we assume the addition
       // files also have this.
@@ -2073,7 +2073,7 @@ char *did_set_spelllang(win_T *wp)
       region_mask = REGION_ALL;
       if (use_region != NULL && !dont_use_region) {
         // find region in sl_regions
-        c = find_region(slang->sl_regions, (char_u *)use_region);
+        c = find_region(slang->sl_regions, use_region);
         if (c != REGION_ALL) {
           region_mask = 1 << c;
         } else if (*slang->sl_regions != NUL) {
@@ -2185,7 +2185,7 @@ static void use_midword(slang_T *lp, win_T *wp)
 // Find the region "region[2]" in "rp" (points to "sl_regions").
 // Each region is simply stored as the two characters of its name.
 // Returns the index if found (first is 0), REGION_ALL if not found.
-static int find_region(const char_u *rp, const char_u *region)
+static int find_region(const char *rp, const char *region)
 {
   int i;
 
@@ -2210,14 +2210,14 @@ static int find_region(const char_u *rp, const char_u *region)
 /// @param[in]  end  End of word or NULL for NUL delimited string
 ///
 /// @returns  Case type of word
-int captype(char_u *word, const char_u *end)
+int captype(char *word, const char *end)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char *p;
 
   // find first letter
-  for (p = (char *)word; !spell_iswordp_nmw((char_u *)p, curwin); MB_PTR_ADV(p)) {
-    if (end == NULL ? *p == NUL : (char_u *)p >= end) {
+  for (p = word; !spell_iswordp_nmw(p, curwin); MB_PTR_ADV(p)) {
+    if (end == NULL ? *p == NUL : p >= end) {
       return 0;             // only non-word characters, illegal word
     }
   }
@@ -2228,8 +2228,8 @@ int captype(char_u *word, const char_u *end)
 
   // Need to check all letters to find a word with mixed upper/lower.
   // But a word with an upper char only at start is a ONECAP.
-  for (; end == NULL ? *p != NUL : (char_u *)p < end; MB_PTR_ADV(p)) {
-    if (spell_iswordp_nmw((char_u *)p, curwin)) {
+  for (; end == NULL ? *p != NUL : p < end; MB_PTR_ADV(p)) {
+    if (spell_iswordp_nmw(p, curwin)) {
       c = utf_ptr2char(p);
       if (!SPELL_ISUPPER(c)) {
         // UUl -> KEEPCAP
@@ -2258,10 +2258,10 @@ int captype(char_u *word, const char_u *end)
 void spell_delete_wordlist(void)
 {
   if (int_wordlist != NULL) {
-    char_u fname[MAXPATHL] = { 0 };
-    os_remove((char *)int_wordlist);
+    char fname[MAXPATHL] = { 0 };
+    os_remove(int_wordlist);
     int_wordlist_spl(fname);
-    os_remove((char *)fname);
+    os_remove(fname);
     XFREE_CLEAR(int_wordlist);
   }
 }
@@ -2393,18 +2393,18 @@ void init_spell_chartab(void)
 /// Thus this only works properly when past the first character of the word.
 ///
 /// @param wp Buffer used.
-bool spell_iswordp(const char_u *p, const win_T *wp)
+bool spell_iswordp(const char *p, const win_T *wp)
   FUNC_ATTR_NONNULL_ALL
 {
-  const int l = utfc_ptr2len((char *)p);
-  const char_u *s = p;
+  const int l = utfc_ptr2len(p);
+  const char *s = p;
   if (l == 1) {
     // be quick for ASCII
-    if (wp->w_s->b_spell_ismw[*p]) {
+    if (wp->w_s->b_spell_ismw[(uint8_t)(*p)]) {
       s = p + 1;                      // skip a mid-word character
     }
   } else {
-    int c = utf_ptr2char((char *)p);
+    int c = utf_ptr2char(p);
     if (c < 256
         ? wp->w_s->b_spell_ismw[c]
         : (wp->w_s->b_spell_ismw_mb != NULL
@@ -2413,20 +2413,20 @@ bool spell_iswordp(const char_u *p, const win_T *wp)
     }
   }
 
-  int c = utf_ptr2char((char *)s);
+  int c = utf_ptr2char(s);
   if (c > 255) {
-    return spell_mb_isword_class(mb_get_class((char *)s), wp);
+    return spell_mb_isword_class(mb_get_class(s), wp);
   }
   return spelltab.st_isw[c];
 }
 
 // Returns true if "p" points to a word character.
 // Unlike spell_iswordp() this doesn't check for "midword" characters.
-bool spell_iswordp_nmw(const char_u *p, win_T *wp)
+bool spell_iswordp_nmw(const char *p, win_T *wp)
 {
-  int c = utf_ptr2char((char *)p);
+  int c = utf_ptr2char(p);
   if (c > 255) {
-    return spell_mb_isword_class(mb_get_class((char *)p), wp);
+    return spell_mb_isword_class(mb_get_class(p), wp);
   }
   return spelltab.st_isw[c];
 }
@@ -2471,7 +2471,7 @@ static bool spell_iswordp_w(const int *p, const win_T *wp)
 // Uses the character definitions from the .spl file.
 // When using a multi-byte 'encoding' the length may change!
 // Returns FAIL when something wrong.
-int spell_casefold(const win_T *wp, char_u *str, int len, char_u *buf, int buflen)
+int spell_casefold(const win_T *wp, char *str, int len, char *buf, int buflen)
   FUNC_ATTR_NONNULL_ALL
 {
   if (len >= buflen) {
@@ -2482,7 +2482,7 @@ int spell_casefold(const win_T *wp, char_u *str, int len, char_u *buf, int bufle
   int outi = 0;
 
   // Fold one character at a time.
-  for (char *p = (char *)str; (char_u *)p < str + len;) {
+  for (char *p = str; p < str + len;) {
     if (outi + MB_MAXBYTES > buflen) {
       buf[outi] = NUL;
       return FAIL;
@@ -2493,7 +2493,7 @@ int spell_casefold(const win_T *wp, char_u *str, int len, char_u *buf, int bufle
     // when it is the last character in a word, then it folds to
     // 0x03C2.
     if (c == 0x03a3 || c == 0x03c2) {
-      if (p == (char *)str + len || !spell_iswordp((char_u *)p, wp)) {
+      if (p == str + len || !spell_iswordp(p, wp)) {
         c = 0x03c2;
       } else {
         c = 0x03c3;
@@ -2502,7 +2502,7 @@ int spell_casefold(const win_T *wp, char_u *str, int len, char_u *buf, int bufle
       c = SPELL_TOFOLD(c);
     }
 
-    outi += utf_char2bytes(c, (char *)buf + outi);
+    outi += utf_char2bytes(c, buf + outi);
   }
   buf[outi] = NUL;
 
@@ -2551,7 +2551,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
     char *p = line + endcol;
     for (;;) {
       MB_PTR_BACK(line, p);
-      if (p == line || spell_iswordp_nmw((char_u *)p, curwin)) {
+      if (p == line || spell_iswordp_nmw(p, curwin)) {
         break;
       }
       if (vim_regexec(&regmatch, p, 0)
@@ -2582,15 +2582,15 @@ void ex_spellrepall(exarg_T *eap)
   int addlen = (int)(strlen(repl_to) - strlen(repl_from));
 
   size_t frompatlen = strlen(repl_from) + 7;
-  char_u *frompat = xmalloc(frompatlen);
-  snprintf((char *)frompat, frompatlen, "\\V\\<%s\\>", repl_from);
+  char *frompat = xmalloc(frompatlen);
+  snprintf(frompat, frompatlen, "\\V\\<%s\\>", repl_from);
   p_ws = false;
 
   sub_nsubs = 0;
   sub_nlines = 0;
   curwin->w_cursor.lnum = 0;
   while (!got_int) {
-    if (do_search(NULL, '/', '/', (char *)frompat, 1L, SEARCH_KEEP, NULL) == 0
+    if (do_search(NULL, '/', '/', frompat, 1L, SEARCH_KEEP, NULL) == 0
         || u_save_cursor() == FAIL) {
       break;
     }
@@ -2600,11 +2600,11 @@ void ex_spellrepall(exarg_T *eap)
     char *line = get_cursor_line_ptr();
     if (addlen <= 0 || strncmp(line + curwin->w_cursor.col,
                                repl_to, strlen(repl_to)) != 0) {
-      char_u *p = xmalloc(strlen(line) + (size_t)addlen + 1);
+      char *p = xmalloc(strlen(line) + (size_t)addlen + 1);
       memmove(p, line, (size_t)curwin->w_cursor.col);
       STRCPY(p + curwin->w_cursor.col, repl_to);
       STRCAT(p, line + curwin->w_cursor.col + strlen(repl_from));
-      ml_replace(curwin->w_cursor.lnum, (char *)p, false);
+      ml_replace(curwin->w_cursor.lnum, p, false);
       changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
 
       if (curwin->w_cursor.lnum != prev_lnum) {
@@ -2634,9 +2634,9 @@ void ex_spellrepall(exarg_T *eap)
 /// @param[in]  word  source string to copy
 /// @param[in,out]  wcopy  copied string, with case of first letter changed
 /// @param[in]  upper  True to upper case, otherwise lower case
-void onecap_copy(char_u *word, char *wcopy, bool upper)
+void onecap_copy(char *word, char *wcopy, bool upper)
 {
-  char *p = (char *)word;
+  char *p = word;
   int c = mb_cptr2char_adv((const char **)&p);
   if (upper) {
     c = SPELL_TOUPPER(c);
@@ -2649,15 +2649,15 @@ void onecap_copy(char_u *word, char *wcopy, bool upper)
 
 // Make a copy of "word" with all the letters upper cased into
 // "wcopy[MAXWLEN]".  The result is NUL terminated.
-void allcap_copy(char_u *word, char_u *wcopy)
+void allcap_copy(char *word, char *wcopy)
 {
-  char_u *d = wcopy;
-  for (char *s = (char *)word; *s != NUL;) {
+  char_u *d = (char_u *)wcopy;
+  for (char *s = word; *s != NUL;) {
     int c = mb_cptr2char_adv((const char **)&s);
 
     if (c == 0xdf) {
       c = 'S';
-      if (d - wcopy >= MAXWLEN - 1) {
+      if (d - (char_u *)wcopy >= MAXWLEN - 1) {
         break;
       }
       *d++ = (char_u)c;
@@ -2665,7 +2665,7 @@ void allcap_copy(char_u *word, char_u *wcopy)
       c = SPELL_TOUPPER(c);
     }
 
-    if (d - wcopy >= MAXWLEN - MB_MAXBYTES) {
+    if (d - (char_u *)wcopy >= MAXWLEN - MB_MAXBYTES) {
       break;
     }
     d += utf_char2bytes(c, (char *)d);
@@ -2675,9 +2675,9 @@ void allcap_copy(char_u *word, char_u *wcopy)
 
 // Case-folding may change the number of bytes: Count nr of chars in
 // fword[flen] and return the byte length of that many chars in "word".
-int nofold_len(char_u *fword, int flen, char_u *word)
+int nofold_len(char *fword, int flen, char *word)
 {
-  char_u *p;
+  char *p;
   int i = 0;
 
   for (p = fword; p < fword + flen; MB_PTR_ADV(p)) {
@@ -2690,14 +2690,14 @@ int nofold_len(char_u *fword, int flen, char_u *word)
 }
 
 // Copy "fword" to "cword", fixing case according to "flags".
-void make_case_word(char_u *fword, char_u *cword, int flags)
+void make_case_word(char *fword, char *cword, int flags)
 {
   if (flags & WF_ALLCAP) {
     // Make it all upper-case
     allcap_copy(fword, cword);
   } else if (flags & WF_ONECAP) {
     // Make the first letter upper-case
-    onecap_copy(fword, (char *)cword, true);
+    onecap_copy(fword, cword, true);
   } else {
     // Use goodword as-is.
     STRCPY(cword, fword);
@@ -2720,9 +2720,9 @@ char *eval_soundfold(const char *const word)
       langp_T *const lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
       if (!GA_EMPTY(&lp->lp_slang->sl_sal)) {
         // soundfold the word
-        char_u sound[MAXWLEN];
-        spell_soundfold(lp->lp_slang, (char *)word, false, (char *)sound);
-        return xstrdup((const char *)sound);
+        char sound[MAXWLEN];
+        spell_soundfold(lp->lp_slang, (char *)word, false, sound);
+        return xstrdup(sound);
       }
     }
   }
@@ -2750,7 +2750,7 @@ void spell_soundfold(slang_T *slang, char *inword, bool folded, char *res)
 {
   if (slang->sl_sofo) {
     // SOFOFROM and SOFOTO used
-    spell_soundfold_sofo(slang, (char_u *)inword, (char_u *)res);
+    spell_soundfold_sofo(slang, inword, res);
   } else {
     char fword[MAXWLEN];
     char *word;
@@ -2758,17 +2758,17 @@ void spell_soundfold(slang_T *slang, char *inword, bool folded, char *res)
     if (folded) {
       word = inword;
     } else {
-      (void)spell_casefold(curwin, (char_u *)inword, (int)strlen(inword), (char_u *)fword, MAXWLEN);
+      (void)spell_casefold(curwin, inword, (int)strlen(inword), fword, MAXWLEN);
       word = fword;
     }
 
-    spell_soundfold_wsal(slang, (char_u *)word, (char_u *)res);
+    spell_soundfold_wsal(slang, word, res);
   }
 }
 
 // Perform sound folding of "inword" into "res" according to SOFOFROM and
 // SOFOTO lines.
-static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
+static void spell_soundfold_sofo(slang_T *slang, char *inword, char *res)
 {
   int ri = 0;
 
@@ -2776,7 +2776,7 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
 
   // The sl_sal_first[] table contains the translation for chars up to
   // 255, sl_sal the rest.
-  for (char *s = (char *)inword; *s != NUL;) {
+  for (char *s = inword; *s != NUL;) {
     int c = mb_cptr2char_adv((const char **)&s);
     if (utf_class(c) == 0) {
       c = ' ';
@@ -2802,7 +2802,7 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
     }
 
     if (c != NUL && c != prevc) {
-      ri += utf_char2bytes(c, (char *)res + ri);
+      ri += utf_char2bytes(c, res + ri);
       if (ri + MB_MAXBYTES > MAXWLEN) {
         break;
       }
@@ -2815,7 +2815,7 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
 
 // Turn "inword" into its sound-a-like equivalent in "res[MAXWLEN]".
 // Multi-byte version of spell_soundfold().
-static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *res)
+static void spell_soundfold_wsal(slang_T *slang, const char *inword, char *res)
 {
   salitem_T *smp = (salitem_T *)slang->sl_sal.ga_data;
   int word[MAXWLEN] = { 0 };
@@ -2849,7 +2849,7 @@ static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *r
         did_white = true;
       } else {
         did_white = false;
-        if (!spell_iswordp_nmw(t, curwin)) {
+        if (!spell_iswordp_nmw((char *)t, curwin)) {
           continue;
         }
       }
@@ -2906,7 +2906,7 @@ static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *r
           }
           k++;
         }
-        char_u *s = smp[n].sm_rules;
+        char_u *s = (char_u *)smp[n].sm_rules;
         pri = 5;            // default priority
 
         p0 = *s;
@@ -2983,7 +2983,7 @@ static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *r
               }
 
               p0 = 5;
-              s = smp[n0].sm_rules;
+              s = (char_u *)smp[n0].sm_rules;
               while (*s == '-') {
                 // "k0" gets NOT reduced because
                 // "if (k0 == k)"
@@ -3024,7 +3024,7 @@ static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *r
 
           // replace string
           ws = smp[n].sm_to_w;
-          s = smp[n].sm_rules;
+          s = (char_u *)smp[n].sm_rules;
           p0 = (vim_strchr((char *)s, '<') != NULL) ? 1 : 0;
           if (p0 == 1 && z == 0) {
             // rule with '<' is used
@@ -3102,7 +3102,7 @@ static void spell_soundfold_wsal(slang_T *slang, const char_u *inword, char_u *r
   // Convert wide characters in "wres" to a multi-byte string in "res".
   int l = 0;
   for (int n = 0; n < reslen; n++) {
-    l += utf_char2bytes(wres[n], (char *)res + l);
+    l += utf_char2bytes(wres[n], res + l);
     if (l + MB_MAXBYTES > MAXWLEN) {
       break;
     }
@@ -3204,7 +3204,7 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
     if (ic) {
       dumpflags |= DUMPFLAG_ICASE;
     } else {
-      n = captype((char_u *)pat, NULL);
+      n = captype(pat, NULL);
       if (n == WF_ONECAP) {
         dumpflags |= DUMPFLAG_ONECAP;
       } else if (n == WF_ALLCAP
@@ -3218,7 +3218,7 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
   // regions or none at all.
   for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
     lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
-    p = (char *)lp->lp_slang->sl_regions;
+    p = lp->lp_slang->sl_regions;
     if (p[0] != 0) {
       if (region_names == NULL) {           // first language with regions
         region_names = p;
@@ -3264,11 +3264,11 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
     for (int round = 1; round <= 2; round++) {
       if (round == 1) {
         dumpflags &= ~DUMPFLAG_KEEPCASE;
-        byts = (char *)slang->sl_fbyts;
+        byts = slang->sl_fbyts;
         idxs = slang->sl_fidxs;
       } else {
         dumpflags |= DUMPFLAG_KEEPCASE;
-        byts = (char *)slang->sl_kbyts;
+        byts = slang->sl_kbyts;
         idxs = slang->sl_kidxs;
       }
       if (byts == NULL) {
@@ -3319,7 +3319,7 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
 
               // Apply the prefix, if there is one.
               if (c != 0) {
-                lnum = dump_prefixes(slang, word, (char_u *)pat, dir,
+                lnum = dump_prefixes(slang, word, pat, dir,
                                      dumpflags, flags, lnum);
               }
             }
@@ -3337,7 +3337,7 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
             // ignore case...
             assert(depth >= 0);
             if (depth <= patlen
-                && mb_strnicmp((char *)word, pat, (size_t)depth) != 0) {
+                && mb_strnicmp(word, pat, (size_t)depth) != 0) {
               depth--;
             }
           }
@@ -3367,12 +3367,12 @@ static void dump_word(slang_T *slang, char *word, char *pat, Direction *dir, int
 
   if ((dumpflags & DUMPFLAG_KEEPCASE) == 0 && (flags & WF_CAPMASK) != 0) {
     // Need to fix case according to "flags".
-    make_case_word((char_u *)word, (char_u *)cword, flags);
+    make_case_word(word, cword, flags);
     p = cword;
   } else {
     p = word;
     if ((dumpflags & DUMPFLAG_KEEPCASE)
-        && ((captype((char_u *)word, NULL) & WF_KEEPCAP) == 0
+        && ((captype(word, NULL) & WF_KEEPCAP) == 0
             || (flags & WF_FIXCAP) != 0)) {
       keepcap = true;
     }
@@ -3436,8 +3436,8 @@ static void dump_word(slang_T *slang, char *word, char *pat, Direction *dir, int
 /// @param flags  flags with prefix ID
 ///
 /// @return  the updated line number.
-static linenr_T dump_prefixes(slang_T *slang, char *word, char_u *pat, Direction *dir,
-                              int dumpflags, int flags, linenr_T startlnum)
+static linenr_T dump_prefixes(slang_T *slang, char *word, char *pat, Direction *dir, int dumpflags,
+                              int flags, linenr_T startlnum)
 {
   idx_T arridx[MAXWLEN];
   int curi[MAXWLEN];
@@ -3450,11 +3450,11 @@ static linenr_T dump_prefixes(slang_T *slang, char *word, char_u *pat, Direction
   // upper-case letter in word_up[].
   int c = utf_ptr2char(word);
   if (SPELL_TOUPPER(c) != c) {
-    onecap_copy((char_u *)word, (char *)word_up, true);
+    onecap_copy(word, word_up, true);
     has_word_up = true;
   }
 
-  char_u *byts = slang->sl_pbyts;
+  char_u *byts = (char_u *)slang->sl_pbyts;
   idx_T *idxs = slang->sl_pidxs;
   if (byts != NULL) {           // array not is empty
     // Loop over all prefixes, building them byte-by-byte in prefix[].
@@ -3484,10 +3484,10 @@ static linenr_T dump_prefixes(slang_T *slang, char *word, char_u *pat, Direction
           }
           curi[depth] += i - 1;
 
-          c = valid_word_prefix(i, n, flags, (char_u *)word, slang, false);
+          c = valid_word_prefix(i, n, flags, word, slang, false);
           if (c != 0) {
             xstrlcpy(prefix + depth, word, (size_t)(MAXWLEN - depth));
-            dump_word(slang, (char *)prefix, (char *)pat, dir, dumpflags,
+            dump_word(slang, prefix, pat, dir, dumpflags,
                       (c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
             if (lnum != 0) {
               lnum++;
@@ -3498,11 +3498,10 @@ static linenr_T dump_prefixes(slang_T *slang, char *word, char_u *pat, Direction
           // first letter is upper-case, but only if the prefix has
           // a condition.
           if (has_word_up) {
-            c = valid_word_prefix(i, n, flags, (char_u *)word_up, slang,
-                                  true);
+            c = valid_word_prefix(i, n, flags, word_up, slang, true);
             if (c != 0) {
               xstrlcpy(prefix + depth, word_up, (size_t)(MAXWLEN - depth));
-              dump_word(slang, (char *)prefix, (char *)pat, dir, dumpflags,
+              dump_word(slang, prefix, pat, dir, dumpflags,
                         (c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
               if (lnum != 0) {
                 lnum++;
@@ -3528,7 +3527,7 @@ char *spell_to_word_end(char *start, win_T *win)
 {
   char *p = start;
 
-  while (*p != NUL && spell_iswordp((char_u *)p, win)) {
+  while (*p != NUL && spell_iswordp(p, win)) {
     MB_PTR_ADV(p);
   }
   return p;
@@ -3545,8 +3544,8 @@ int spell_word_start(int startcol)
     return startcol;
   }
 
-  char_u *line = (char_u *)get_cursor_line_ptr();
-  char_u *p;
+  char *line = get_cursor_line_ptr();
+  char *p;
 
   // Find a word character before "startcol".
   for (p = line + startcol; p > line;) {
@@ -3588,7 +3587,7 @@ int expand_spelling(linenr_T lnum, char *pat, char ***matchp)
 {
   garray_T ga;
 
-  spell_suggest_list(&ga, (char_u *)pat, 100, spell_expand_need_cap, true);
+  spell_suggest_list(&ga, pat, 100, spell_expand_need_cap, true);
   *matchp = ga.ga_data;
   return ga.ga_len;
 }
diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h
index 4d146a1706..726af7d698 100644
--- a/src/nvim/spell_defs.h
+++ b/src/nvim/spell_defs.h
@@ -80,11 +80,11 @@ typedef struct fromto_S {
 // The info is split for quick processing by spell_soundfold().
 // Note that "sm_oneof" and "sm_rules" point into sm_lead.
 typedef struct salitem_S {
-  char_u *sm_lead;         // leading letters
-  int sm_leadlen;               // length of "sm_lead"
-  char_u *sm_oneof;        // letters from () or NULL
-  char_u *sm_rules;        // rules like ^, $, priority
-  char_u *sm_to;           // replacement.
+  char *sm_lead;        // leading letters
+  int sm_leadlen;       // length of "sm_lead"
+  char_u *sm_oneof;     // letters from () or NULL
+  char *sm_rules;       // rules like ^, $, priority
+  char *sm_to;          // replacement.
   int *sm_lead_w;       // wide character copy of "sm_lead"
   int *sm_oneof_w;      // wide character copy of "sm_oneof"
   int *sm_to_w;         // wide character copy of "sm_to"
@@ -119,17 +119,17 @@ struct slang_S {
   char *sl_fname;           // name of .spl file
   bool sl_add;              // true if it's a .add file.
 
-  char_u *sl_fbyts;        // case-folded word bytes
+  char *sl_fbyts;        // case-folded word bytes
   long sl_fbyts_len;     // length of sl_fbyts
   idx_T *sl_fidxs;        // case-folded word indexes
-  char_u *sl_kbyts;        // keep-case word bytes
+  char *sl_kbyts;         // keep-case word bytes
   idx_T *sl_kidxs;        // keep-case word indexes
-  char_u *sl_pbyts;        // prefix tree word bytes
+  char *sl_pbyts;        // prefix tree word bytes
   idx_T *sl_pidxs;        // prefix tree word indexes
 
   char_u *sl_info;         // infotext string or NULL
 
-  char_u sl_regions[MAXREGIONS * 2 + 1];
+  char sl_regions[MAXREGIONS * 2 + 1];
   // table with up to 8 region names plus NUL
 
   char_u *sl_midword;      // MIDWORD string or NULL
@@ -143,9 +143,9 @@ struct slang_S {
   garray_T sl_comppat;          // CHECKCOMPOUNDPATTERN items
   regprog_T *sl_compprog;     // COMPOUNDRULE turned into a regexp progrm
                               // (NULL when no compounding)
-  char_u *sl_comprules;    // all COMPOUNDRULE concatenated (or NULL)
-  char_u *sl_compstartflags;   // flags for first compound word
-  char_u *sl_compallflags;   // all flags for compound words
+  uint8_t *sl_comprules;        // all COMPOUNDRULE concatenated (or NULL)
+  uint8_t *sl_compstartflags;   // flags for first compound word
+  uint8_t *sl_compallflags;     // all flags for compound words
   bool sl_nobreak;              // When true: no spaces between words
   char_u *sl_syllable;     // SYLLABLE repeatable chars or NULL
   garray_T sl_syl_items;        // syllable items
@@ -172,7 +172,7 @@ struct slang_S {
 
   // Info from the .sug file.  Loaded on demand.
   time_t sl_sugtime;            // timestamp for .sug file
-  char_u *sl_sbyts;        // soundfolded word bytes
+  char *sl_sbyts;         // soundfolded word bytes
   idx_T *sl_sidxs;        // soundfolded word indexes
   buf_T *sl_sugbuf;       // buffer with word number table
   bool sl_sugloaded;            // true when .sug file was loaded or failed to
@@ -227,7 +227,7 @@ typedef struct {
 extern slang_T *first_lang;
 
 // file used for "zG" and "zW"
-extern char_u *int_wordlist;
+extern char *int_wordlist;
 
 extern spelltab_T spelltab;
 extern int did_set_spelltab;
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 6f5bd836b1..a7219e23dd 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -336,7 +336,7 @@ static char *msg_compressing = N_("Compressing word tree...");
                                 // and .dic file.
 // Main structure to store the contents of a ".aff" file.
 typedef struct afffile_S {
-  char_u *af_enc;          // "SET", normalized, alloc'ed string or NULL
+  char *af_enc;                 // "SET", normalized, alloc'ed string or NULL
   int af_flagtype;              // AFT_CHAR, AFT_LONG, AFT_NUM or AFT_CAPLONG
   unsigned af_rare;             // RARE ID for rare word
   unsigned af_keepcase;         // KEEPCASE ID for keep-case word
@@ -364,12 +364,12 @@ typedef struct afffile_S {
 typedef struct affentry_S affentry_T;
 // Affix entry from ".aff" file.  Used for prefixes and suffixes.
 struct affentry_S {
-  affentry_T *ae_next;         // next affix with same name/number
-  char *ae_chop;           // text to chop off basic word (can be NULL)
-  char *ae_add;            // text to add to basic word (can be NULL)
-  char_u *ae_flags;        // flags on the affix (can be NULL)
-  char_u *ae_cond;         // condition (NULL for ".")
-  regprog_T *ae_prog;         // regexp program for ae_cond or NULL
+  affentry_T *ae_next;          // next affix with same name/number
+  char *ae_chop;                // text to chop off basic word (can be NULL)
+  char *ae_add;                 // text to add to basic word (can be NULL)
+  char *ae_flags;               // flags on the affix (can be NULL)
+  char *ae_cond;                // condition (NULL for ".")
+  regprog_T *ae_prog;           // regexp program for ae_cond or NULL
   char ae_compforbid;           // COMPOUNDFORBIDFLAG found
   char ae_comppermit;           // COMPOUNDPERMITFLAG found
 };
@@ -724,7 +724,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
       if (p == NULL) {
         goto endFAIL;
       }
-      set_map_str(lp, (char_u *)p);
+      set_map_str(lp, p);
       xfree(p);
       break;
 
@@ -1004,8 +1004,8 @@ someerror:
 
       // Need to put word counts in the word tries, so that we can find
       // a word by its number.
-      tree_count_words(slang->sl_fbyts, slang->sl_fidxs);
-      tree_count_words(slang->sl_sbyts, slang->sl_sidxs);
+      tree_count_words((char_u *)slang->sl_fbyts, slang->sl_fidxs);
+      tree_count_words((char_u *)slang->sl_sbyts, slang->sl_sidxs);
 
 nextone:
       if (fd != NULL) {
@@ -1054,7 +1054,7 @@ static int read_region_section(FILE *fd, slang_T *lp, int len)
   if (len > MAXREGIONS * 2) {
     return SP_FORMERROR;
   }
-  SPELL_READ_NONNUL_BYTES((char *)lp->sl_regions, (size_t)len, fd,; );  // NOLINT(whitespace/parens)
+  SPELL_READ_NONNUL_BYTES(lp->sl_regions, (size_t)len, fd,; );  // NOLINT(whitespace/parens)
   lp->sl_regions[len] = NUL;
   return 0;
 }
@@ -1083,7 +1083,7 @@ static int read_charflags_section(FILE *fd)
 
   // Set the word-char flags and fill SPELL_ISUPPER() table.
   if (flags != NULL && fol != NULL) {
-    set_spell_charflags((char_u *)flags, flagslen, fol);
+    set_spell_charflags((char_u *)flags, flagslen, (char *)fol);
   }
 
   xfree(flags);
@@ -1219,7 +1219,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
       return SP_TRUNCERROR;
     }
     p = xmalloc((size_t)ccnt + 2);
-    smp->sm_lead = p;
+    smp->sm_lead = (char *)p;
 
     // Read up to the first special char into sm_lead.
     int i = 0;
@@ -1230,7 +1230,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
       }
       *p++ = (char_u)c;
     }
-    smp->sm_leadlen = (int)(p - smp->sm_lead);
+    smp->sm_leadlen = (int)(p - (char_u *)smp->sm_lead);
     *p++ = NUL;
 
     // Put (abc) chars in sm_oneof, if any.
@@ -1252,7 +1252,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     }
 
     // Any following chars go in sm_rules.
-    smp->sm_rules = p;
+    smp->sm_rules = (char *)p;
     if (i < ccnt) {
       // store the char we got while checking for end of sm_lead
       *p++ = (char_u)c;
@@ -1267,7 +1267,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     *p++ = NUL;
 
     // <saltolen> <salto>
-    smp->sm_to = read_cnt_string(fd, 1, &ccnt);
+    smp->sm_to = (char *)read_cnt_string(fd, 1, &ccnt);
     if (ccnt < 0) {
       xfree(smp->sm_lead);
       return ccnt;
@@ -1275,11 +1275,11 @@ static int read_sal_section(FILE *fd, slang_T *slang)
 
     // convert the multi-byte strings to wide char strings
     smp->sm_lead_w = mb_str2wide(smp->sm_lead);
-    smp->sm_leadlen = mb_charlen((char *)smp->sm_lead);
+    smp->sm_leadlen = mb_charlen(smp->sm_lead);
     if (smp->sm_oneof == NULL) {
       smp->sm_oneof_w = NULL;
     } else {
-      smp->sm_oneof_w = mb_str2wide(smp->sm_oneof);
+      smp->sm_oneof_w = mb_str2wide((char *)smp->sm_oneof);
     }
     if (smp->sm_to == NULL) {
       smp->sm_to_w = NULL;
@@ -1294,12 +1294,12 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     smp = &((salitem_T *)gap->ga_data)[gap->ga_len];
     p = xmalloc(1);
     p[0] = NUL;
-    smp->sm_lead = p;
+    smp->sm_lead = (char *)p;
     smp->sm_lead_w = mb_str2wide(smp->sm_lead);
     smp->sm_leadlen = 0;
     smp->sm_oneof = NULL;
     smp->sm_oneof_w = NULL;
-    smp->sm_rules = p;
+    smp->sm_rules = (char *)p;
     smp->sm_to = NULL;
     smp->sm_to_w = NULL;
     gap->ga_len++;
@@ -1348,19 +1348,19 @@ static int read_words_section(FILE *fd, slang_T *lp, int len)
 static int read_sofo_section(FILE *fd, slang_T *slang)
 {
   int cnt;
-  char_u *from, *to;
+  char *from, *to;
   int res;
 
   slang->sl_sofo = true;
 
   // <sofofromlen> <sofofrom>
-  from = read_cnt_string(fd, 2, &cnt);
+  from = (char *)read_cnt_string(fd, 2, &cnt);
   if (cnt < 0) {
     return cnt;
   }
 
   // <sofotolen> <sofoto>
-  to = read_cnt_string(fd, 2, &cnt);
+  to = (char *)read_cnt_string(fd, 2, &cnt);
   if (cnt < 0) {
     xfree(from);
     return cnt;
@@ -1451,25 +1451,25 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
   // Conversion to utf-8 may double the size.
   c = todo * 2 + 7;
   c += todo * 2;
-  char_u *pat = xmalloc((size_t)c);
+  char *pat = xmalloc((size_t)c);
 
   // We also need a list of all flags that can appear at the start and one
   // for all flags.
-  char_u *cp = xmalloc((size_t)todo + 1);
+  uint8_t *cp = xmalloc((size_t)todo + 1);
   slang->sl_compstartflags = cp;
   *cp = NUL;
 
-  char_u *ap = xmalloc((size_t)todo + 1);
+  uint8_t *ap = xmalloc((size_t)todo + 1);
   slang->sl_compallflags = ap;
   *ap = NUL;
 
   // And a list of all patterns in their original form, for checking whether
   // compounding may work in match_compoundrule().  This is freed when we
   // encounter a wildcard, the check doesn't work then.
-  char_u *crp = xmalloc((size_t)todo + 1);
+  uint8_t *crp = xmalloc((size_t)todo + 1);
   slang->sl_comprules = crp;
 
-  char_u *pp = pat;
+  char_u *pp = (char_u *)pat;
   *pp++ = '^';
   *pp++ = '\\';
   *pp++ = '(';
@@ -1538,7 +1538,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
     *crp = NUL;
   }
 
-  slang->sl_compprog = vim_regcomp((char *)pat, RE_MAGIC + RE_STRING + RE_STRICT);
+  slang->sl_compprog = vim_regcomp(pat, RE_MAGIC + RE_STRING + RE_STRICT);
   xfree(pat);
   if (slang->sl_compprog == NULL) {
     return SP_FORMERROR;
@@ -1549,7 +1549,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
 
 // Set the SOFOFROM and SOFOTO items in language "lp".
 // Returns SP_*ERROR flags when there is something wrong.
-static int set_sofo(slang_T *lp, char_u *from, char_u *to)
+static int set_sofo(slang_T *lp, char *from, char *to)
 {
   char *s;
   char *p;
@@ -1566,7 +1566,7 @@ static int set_sofo(slang_T *lp, char_u *from, char_u *to)
 
   // First count the number of items for each list.  Temporarily use
   // sl_sal_first[] for this.
-  for (p = (char *)from, s = (char *)to; *p != NUL && *s != NUL;) {
+  for (p = from, s = to; *p != NUL && *s != NUL;) {
     const int c = mb_cptr2char_adv((const char **)&p);
     MB_CPTR_ADV(s);
     if (c >= 256) {
@@ -1589,7 +1589,7 @@ static int set_sofo(slang_T *lp, char_u *from, char_u *to)
   // Put the characters up to 255 in sl_sal_first[] the rest in a sl_sal
   // list.
   memset(lp->sl_sal_first, 0, sizeof(salfirst_T) * 256);
-  for (p = (char *)from, s = (char *)to; *p != NUL && *s != NUL;) {
+  for (p = from, s = to; *p != NUL && *s != NUL;) {
     const int c = mb_cptr2char_adv((const char **)&p);
     const int i = mb_cptr2char_adv((const char **)&s);
     if (c >= 256) {
@@ -1660,12 +1660,12 @@ static void set_sal_first(slang_T *lp)
 
 // Turn a multi-byte string into a wide character string.
 // Return it in allocated memory.
-static int *mb_str2wide(char_u *s)
+static int *mb_str2wide(char *s)
 {
   int i = 0;
 
-  int *res = xmalloc(((size_t)mb_charlen((char *)s) + 1) * sizeof(int));
-  for (char *p = (char *)s; *p != NUL;) {
+  int *res = xmalloc(((size_t)mb_charlen(s) + 1) * sizeof(int));
+  for (char *p = s; *p != NUL;) {
     res[i++] = mb_ptr2char_adv((const char **)&p);
   }
   res[i] = NUL;
@@ -1681,12 +1681,12 @@ static int *mb_str2wide(char_u *s)
 /// @param prefixcnt  when "prefixtree" is true: prefix count
 ///
 /// @return  zero when OK, SP_ value for an error.
-static int spell_read_tree(FILE *fd, char_u **bytsp, long *bytsp_len, idx_T **idxsp,
-                           bool prefixtree, int prefixcnt)
+static int spell_read_tree(FILE *fd, char **bytsp, long *bytsp_len, idx_T **idxsp, bool prefixtree,
+                           int prefixcnt)
   FUNC_ATTR_NONNULL_ARG(1, 2, 4)
 {
   int idx;
-  char_u *bp;
+  char *bp;
   idx_T *ip;
 
   // The tree size was computed when writing the file, so that we can
@@ -1712,7 +1712,7 @@ static int spell_read_tree(FILE *fd, char_u **bytsp, long *bytsp_len, idx_T **id
     *idxsp = ip;
 
     // Recursively read the tree and store it in the array.
-    idx = read_tree_node(fd, bp, ip, (int)len, 0, prefixtree, prefixcnt);
+    idx = read_tree_node(fd, (char_u *)bp, ip, (int)len, 0, prefixtree, prefixcnt);
     if (idx < 0) {
       return idx;
     }
@@ -1839,15 +1839,15 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
 /// Reload the spell file "fname" if it's loaded.
 ///
 /// @param added_word  invoked through "zg"
-static void spell_reload_one(char_u *fname, bool added_word)
+static void spell_reload_one(char *fname, bool added_word)
 {
   slang_T *slang;
   bool didit = false;
 
   for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-    if (path_full_compare((char *)fname, slang->sl_fname, false, true) == kEqualFiles) {
+    if (path_full_compare(fname, slang->sl_fname, false, true) == kEqualFiles) {
       slang_clear(slang);
-      if (spell_load_file((char *)fname, NULL, slang, false) == NULL) {
+      if (spell_load_file(fname, NULL, slang, false) == NULL) {
         // reloading failed, clear the language
         slang_clear(slang);
       }
@@ -2021,12 +2021,12 @@ static void spell_print_tree(wordnode_T *root)
 
 // Reads the affix file "fname".
 // Returns an afffile_T, NULL for complete failure.
-static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
+static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 {
   FILE *fd;
-  char_u rline[MAXLINELEN];
-  char_u *line;
-  char_u *pc = NULL;
+  char rline[MAXLINELEN];
+  char *line;
+  char *pc = NULL;
 #define MAXITEMCNT  30
   char *(items[MAXITEMCNT]);
   int itemcnt;
@@ -2052,13 +2052,13 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   int compmax = 0;                 // COMPOUNDWORDMAX value
   char *compflags = NULL;          // COMPOUNDFLAG and COMPOUNDRULE
                                    // concatenated
-  char_u *midword = NULL;          // MIDWORD value
-  char_u *syllable = NULL;         // SYLLABLE value
-  char_u *sofofrom = NULL;         // SOFOFROM value
-  char_u *sofoto = NULL;           // SOFOTO value
+  char *midword = NULL;            // MIDWORD value
+  char *syllable = NULL;           // SYLLABLE value
+  char *sofofrom = NULL;           // SOFOFROM value
+  char *sofoto = NULL;             // SOFOTO value
 
   // Open the file.
-  fd = os_fopen((char *)fname, "r");
+  fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return NULL;
@@ -2086,7 +2086,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   hash_init(&aff->af_comp);
 
   // Read all the lines in the file one by one.
-  while (!vim_fgets((char *)rline, MAXLINELEN, fd) && !got_int) {
+  while (!vim_fgets(rline, MAXLINELEN, fd) && !got_int) {
     line_breakcheck();
     lnum++;
 
@@ -2098,7 +2098,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     // Convert from "SET" to 'encoding' when needed.
     xfree(pc);
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = (char_u *)string_convert(&spin->si_conv, (char *)rline, NULL);
+      pc = string_convert(&spin->si_conv, rline, NULL);
       if (pc == NULL) {
         smsg(_("Conversion failure for word in %s line %d: %s"),
              fname, lnum, rline);
@@ -2113,7 +2113,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     // Split the line up in white separated items.  Put a NUL after each
     // item.
     itemcnt = 0;
-    for (p = (char *)line;;) {
+    for (p = line;;) {
       while (*p != NUL && (uint8_t)(*p) <= ' ') {  // skip white space and CR/NL
         p++;
       }
@@ -2144,9 +2144,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     if (itemcnt > 0) {
       if (is_aff_rule(items, itemcnt, "SET", 2) && aff->af_enc == NULL) {
         // Setup for conversion from "ENC" to 'encoding'.
-        aff->af_enc = (char_u *)enc_canonize((char *)items[1]);
+        aff->af_enc = enc_canonize((char *)items[1]);
         if (!spin->si_ascii
-            && convert_setup(&spin->si_conv, (char *)aff->af_enc, p_enc) == FAIL) {
+            && convert_setup(&spin->si_conv, aff->af_enc, p_enc) == FAIL) {
           smsg(_("Conversion in %s not supported: from %s to %s"),
                fname, aff->af_enc, p_enc);
         }
@@ -2191,57 +2191,47 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         STRCAT(p, items[1]);
         spin->si_info = p;
       } else if (is_aff_rule(items, itemcnt, "MIDWORD", 2) && midword == NULL) {
-        midword = (char_u *)getroom_save(spin, items[1]);
+        midword = getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "TRY", 2)) {
         // ignored, we look in the tree for what chars may appear
       } else if ((is_aff_rule(items, itemcnt, "RAR", 2)  // TODO(vim): remove "RAR" later
                   || is_aff_rule(items, itemcnt, "RARE", 2))
                  && aff->af_rare == 0) {
-        aff->af_rare = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                    fname, lnum);
+        aff->af_rare = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if ((is_aff_rule(items, itemcnt, "KEP", 2)  // TODO(vim): remove "KEP" later
                   || is_aff_rule(items, itemcnt, "KEEPCASE", 2))
                  && aff->af_keepcase == 0) {
-        aff->af_keepcase = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                        fname, lnum);
+        aff->af_keepcase = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if ((is_aff_rule(items, itemcnt, "BAD", 2)
                   || is_aff_rule(items, itemcnt, "FORBIDDENWORD", 2))
                  && aff->af_bad == 0) {
-        aff->af_bad = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                   fname, lnum);
+        aff->af_bad = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "NEEDAFFIX", 2)
                  && aff->af_needaffix == 0) {
-        aff->af_needaffix = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                         fname, lnum);
+        aff->af_needaffix = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "CIRCUMFIX", 2)
                  && aff->af_circumfix == 0) {
-        aff->af_circumfix = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                         fname, lnum);
+        aff->af_circumfix = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "NOSUGGEST", 2)
                  && aff->af_nosuggest == 0) {
-        aff->af_nosuggest = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                         fname, lnum);
+        aff->af_nosuggest = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if ((is_aff_rule(items, itemcnt, "NEEDCOMPOUND", 2)
                   || is_aff_rule(items, itemcnt, "ONLYINCOMPOUND", 2))
                  && aff->af_needcomp == 0) {
-        aff->af_needcomp = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                        fname, lnum);
+        aff->af_needcomp = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDROOT", 2)
                  && aff->af_comproot == 0) {
-        aff->af_comproot = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                        fname, lnum);
+        aff->af_comproot = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDFORBIDFLAG", 2)
                  && aff->af_compforbid == 0) {
-        aff->af_compforbid = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                          fname, lnum);
+        aff->af_compforbid = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
         if (aff->af_pref.ht_used > 0) {
           smsg(_("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
                fname, lnum);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDPERMITFLAG", 2)
                  && aff->af_comppermit == 0) {
-        aff->af_comppermit = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                          fname, lnum);
+        aff->af_comppermit = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
         if (aff->af_pref.ht_used > 0) {
           smsg(_("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
                fname, lnum);
@@ -2330,7 +2320,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
       } else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
                  && syllable == NULL) {
-        syllable = (char_u *)getroom_save(spin, items[1]);
+        syllable = getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "NOBREAK", 1)) {
         spin->si_nobreak = true;
       } else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1)) {
@@ -2375,8 +2365,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         } else {
           // New affix letter.
           cur_aff = getroom(spin, sizeof(*cur_aff), true);
-          cur_aff->ah_flag = affitem2flag(aff->af_flagtype, (char_u *)items[1],
-                                          fname, lnum);
+          cur_aff->ah_flag = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
           if (cur_aff->ah_flag == 0 || strlen(items[1]) >= AH_KEY_LEN) {
             break;
           }
@@ -2469,7 +2458,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           aff_entry->ae_add = getroom_save(spin, items[3]);
 
           // Recognize flags on the affix: abcd/XYZ
-          aff_entry->ae_flags = (char_u *)vim_strchr(aff_entry->ae_add, '/');
+          aff_entry->ae_flags = vim_strchr(aff_entry->ae_add, '/');
           if (aff_entry->ae_flags != NULL) {
             *aff_entry->ae_flags++ = NUL;
             aff_process_flags(aff, aff_entry);
@@ -2484,15 +2473,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           cur_aff->ah_first = aff_entry;
 
           if (strcmp(items[4], ".") != 0) {
-            char_u buf[MAXLINELEN];
+            char buf[MAXLINELEN];
 
-            aff_entry->ae_cond = (char_u *)getroom_save(spin, items[4]);
+            aff_entry->ae_cond = getroom_save(spin, items[4]);
             if (*items[0] == 'P') {
-              sprintf((char *)buf, "^%s", items[4]);  // NOLINT(runtime/printf)
+              sprintf(buf, "^%s", items[4]);  // NOLINT(runtime/printf)
             } else {
-              sprintf((char *)buf, "%s$", items[4]);  // NOLINT(runtime/printf)
+              sprintf(buf, "%s$", items[4]);  // NOLINT(runtime/printf)
             }
-            aff_entry->ae_prog = vim_regcomp((char *)buf, RE_MAGIC + RE_STRING + RE_STRICT);
+            aff_entry->ae_prog = vim_regcomp(buf, RE_MAGIC + RE_STRING + RE_STRICT);
             if (aff_entry->ae_prog == NULL) {
               smsg(_("Broken condition in %s line %d: %s"),
                    fname, lnum, items[4]);
@@ -2520,7 +2509,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               c_up = SPELL_TOUPPER(c);
               if (c_up != c
                   && (aff_entry->ae_cond == NULL
-                      || utf_ptr2char((char *)aff_entry->ae_cond) == c)) {
+                      || utf_ptr2char(aff_entry->ae_cond) == c)) {
                 p = aff_entry->ae_add + strlen(aff_entry->ae_add);
                 MB_PTR_BACK(aff_entry->ae_add, p);
                 if (utf_ptr2char(p) == c_up) {
@@ -2532,13 +2521,13 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                   // actual word, thus must check for the
                   // upper-case letter.
                   if (aff_entry->ae_cond != NULL) {
-                    char_u buf[MAXLINELEN];
-                    onecap_copy((char_u *)items[4], (char *)buf, true);
-                    aff_entry->ae_cond = (char_u *)getroom_save(spin, (char *)buf);
+                    char buf[MAXLINELEN];
+                    onecap_copy(items[4], buf, true);
+                    aff_entry->ae_cond = getroom_save(spin, buf);
                     if (aff_entry->ae_cond != NULL) {
-                      sprintf((char *)buf, "^%s", aff_entry->ae_cond);  // NOLINT(runtime/printf)
+                      sprintf(buf, "^%s", aff_entry->ae_cond);  // NOLINT(runtime/printf)
                       vim_regfree(aff_entry->ae_prog);
-                      aff_entry->ae_prog = vim_regcomp((char *)buf, RE_MAGIC + RE_STRING);
+                      aff_entry->ae_prog = vim_regcomp(buf, RE_MAGIC + RE_STRING);
                     }
                   }
                 }
@@ -2553,7 +2542,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               // Find a previously used condition.
               for (idx = spin->si_prefcond.ga_len - 1; idx >= 0; idx--) {
                 p = ((char **)spin->si_prefcond.ga_data)[idx];
-                if (str_equal(p, (char *)aff_entry->ae_cond)) {
+                if (str_equal(p, aff_entry->ae_cond)) {
                   break;
                 }
               }
@@ -2562,7 +2551,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                 idx = spin->si_prefcond.ga_len;
                 pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
                 *pp = (aff_entry->ae_cond == NULL) ?
-                      NULL : (char_u *)getroom_save(spin, (char *)aff_entry->ae_cond);
+                      NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
@@ -2688,10 +2677,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
       } else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
                  && sofofrom == NULL) {
-        sofofrom = (char_u *)getroom_save(spin, items[1]);
+        sofofrom = getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
                  && sofoto == NULL) {
-        sofoto = (char_u *)getroom_save(spin, items[1]);
+        sofoto = getroom_save(spin, items[1]);
       } else if (strcmp(items[0], "COMMON") == 0) {
         int i;
 
@@ -2761,8 +2750,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   }
 
   if (syllable != NULL) {
-    aff_check_string(spin->si_syllable, (char *)syllable, "SYLLABLE");
-    spin->si_syllable = (char *)syllable;
+    aff_check_string(spin->si_syllable, syllable, "SYLLABLE");
+    spin->si_syllable = syllable;
   }
 
   if (sofofrom != NULL || sofoto != NULL) {
@@ -2772,16 +2761,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     } else if (!GA_EMPTY(&spin->si_sal)) {
       smsg(_("Both SAL and SOFO lines in %s"), fname);
     } else {
-      aff_check_string(spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
-      aff_check_string(spin->si_sofoto, (char *)sofoto, "SOFOTO");
-      spin->si_sofofr = (char *)sofofrom;
-      spin->si_sofoto = (char *)sofoto;
+      aff_check_string(spin->si_sofofr, sofofrom, "SOFOFROM");
+      aff_check_string(spin->si_sofoto, sofoto, "SOFOTO");
+      spin->si_sofofr = sofofrom;
+      spin->si_sofoto = sofoto;
     }
   }
 
   if (midword != NULL) {
-    aff_check_string(spin->si_midword, (char *)midword, "MIDWORD");
-    spin->si_midword = (char *)midword;
+    aff_check_string(spin->si_midword, midword, "MIDWORD");
+    spin->si_midword = midword;
   }
 
   xfree(pc);
@@ -2808,7 +2797,7 @@ static void aff_process_flags(afffile_T *affile, affentry_T *entry)
 
   if (entry->ae_flags != NULL
       && (affile->af_compforbid != 0 || affile->af_comppermit != 0)) {
-    for (p = (char *)entry->ae_flags; *p != NUL;) {
+    for (p = entry->ae_flags; *p != NUL;) {
       prevp = (char_u *)p;
       flag = get_affitem(affile->af_flagtype, &p);
       if (flag == affile->af_comppermit || flag == affile->af_compforbid) {
@@ -2843,10 +2832,10 @@ static bool spell_info_item(char *s)
 
 // Turn an affix flag name into a number, according to the FLAG type.
 // returns zero for failure.
-static unsigned affitem2flag(int flagtype, char_u *item, char_u *fname, int lnum)
+static unsigned affitem2flag(int flagtype, char *item, char *fname, int lnum)
 {
   unsigned res;
-  char *p = (char *)item;
+  char *p = item;
 
   res = get_affitem(flagtype, &p);
   if (res == 0) {
@@ -2978,18 +2967,18 @@ static void check_renumber(spellinfo_T *spin)
 }
 
 // Returns true if flag "flag" appears in affix list "afflist".
-static bool flag_in_afflist(int flagtype, char_u *afflist, unsigned flag)
+static bool flag_in_afflist(int flagtype, char *afflist, unsigned flag)
 {
   char *p;
   unsigned n;
 
   switch (flagtype) {
   case AFT_CHAR:
-    return vim_strchr((char *)afflist, (int)flag) != NULL;
+    return vim_strchr(afflist, (int)flag) != NULL;
 
   case AFT_CAPLONG:
   case AFT_LONG:
-    for (p = (char *)afflist; *p != NUL;) {
+    for (p = afflist; *p != NUL;) {
       n = (unsigned)mb_ptr2char_adv((const char **)&p);
       if ((flagtype == AFT_LONG || (n >= 'A' && n <= 'Z'))
           && *p != NUL) {
@@ -3002,7 +2991,7 @@ static bool flag_in_afflist(int flagtype, char_u *afflist, unsigned flag)
     break;
 
   case AFT_NUM:
-    for (p = (char *)afflist; *p != NUL;) {
+    for (p = afflist; *p != NUL;) {
       int digits = getdigits_int(&p, true, 0);
       assert(digits >= 0);
       n = (unsigned int)digits;
@@ -3053,13 +3042,13 @@ static bool str_equal(char *s1, char *s2)
 /// They are stored case-folded.
 static void add_fromto(spellinfo_T *spin, garray_T *gap, char *from, char *to)
 {
-  char_u word[MAXWLEN];
+  char word[MAXWLEN];
 
   fromto_T *ftp = GA_APPEND_VIA_PTR(fromto_T, gap);
-  (void)spell_casefold(curwin, (char_u *)from, (int)strlen(from), word, MAXWLEN);
-  ftp->ft_from = getroom_save(spin, (char *)word);
-  (void)spell_casefold(curwin, (char_u *)to, (int)strlen(to), word, MAXWLEN);
-  ftp->ft_to = getroom_save(spin, (char *)word);
+  (void)spell_casefold(curwin, from, (int)strlen(from), word, MAXWLEN);
+  ftp->ft_from = getroom_save(spin, word);
+  (void)spell_casefold(curwin, to, (int)strlen(to), word, MAXWLEN);
+  ftp->ft_to = getroom_save(spin, word);
 }
 
 /// Converts a boolean argument in a SAL line to true or false;
@@ -3103,7 +3092,7 @@ static void spell_free_aff(afffile_T *aff)
 
 // Read dictionary file "fname".
 // Returns OK or FAIL;
-static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
+static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
 {
   hashtab_T ht;
   char line[MAXLINELEN];
@@ -3128,7 +3117,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
   Timestamp last_msg_time = 0;
 
   // Open the file.
-  fd = os_fopen((char *)fname, "r");
+  fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return FAIL;
@@ -3250,17 +3239,17 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
     need_affix = false;
     if (afflist != NULL) {
       // Extract flags from the affix list.
-      flags |= get_affix_flags(affile, afflist);
+      flags |= get_affix_flags(affile, (char *)afflist);
 
       if (affile->af_needaffix != 0
-          && flag_in_afflist(affile->af_flagtype, afflist,
+          && flag_in_afflist(affile->af_flagtype, (char *)afflist,
                              affile->af_needaffix)) {
         need_affix = true;
       }
 
       if (affile->af_pfxpostpone) {
         // Need to store the list of prefix IDs with the word.
-        pfxlen = get_pfxlist(affile, afflist, store_afflist);
+        pfxlen = get_pfxlist(affile, (char *)afflist, store_afflist);
       }
 
       if (spin->si_compflags != NULL) {
@@ -3272,21 +3261,21 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
 
     // Add the word to the word tree(s).
     if (store_word(spin, dw, flags, spin->si_region,
-                   store_afflist, need_affix) == FAIL) {
+                   (char *)store_afflist, need_affix) == FAIL) {
       retval = FAIL;
     }
 
     if (afflist != NULL) {
       // Find all matching suffixes and add the resulting words.
       // Additionally do matching prefixes that combine.
-      if (store_aff_word(spin, dw, afflist, affile,
+      if (store_aff_word(spin, dw, (char *)afflist, affile,
                          &affile->af_suff, &affile->af_pref,
                          CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
         retval = FAIL;
       }
 
       // Find all matching prefixes and add the resulting words.
-      if (store_aff_word(spin, dw, afflist, affile,
+      if (store_aff_word(spin, dw, (char *)afflist, affile,
                          &affile->af_pref, NULL,
                          CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
         retval = FAIL;
@@ -3311,7 +3300,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
 
 // Check for affix flags in "afflist" that are turned into word flags.
 // Return WF_ flags.
-static int get_affix_flags(afffile_T *affile, char_u *afflist)
+static int get_affix_flags(afffile_T *affile, char *afflist)
 {
   int flags = 0;
 
@@ -3350,7 +3339,7 @@ static int get_affix_flags(afffile_T *affile, char_u *afflist)
 // Used for PFXPOSTPONE.
 // Put the resulting flags in "store_afflist[MAXWLEN]" with a terminating NUL
 // and return the number of affixes.
-static int get_pfxlist(afffile_T *affile, char_u *afflist, char_u *store_afflist)
+static int get_pfxlist(afffile_T *affile, char *afflist, char_u *store_afflist)
 {
   char *p;
   char *prevp;
@@ -3359,7 +3348,7 @@ static int get_pfxlist(afffile_T *affile, char_u *afflist, char_u *store_afflist
   char key[AH_KEY_LEN];
   hashitem_T *hi;
 
-  for (p = (char *)afflist; *p != NUL;) {
+  for (p = afflist; *p != NUL;) {
     prevp = p;
     if (get_affitem(affile->af_flagtype, &p) != 0) {
       // A flag is a postponed prefix flag if it appears in "af_pref"
@@ -3426,7 +3415,7 @@ static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflis
 /// @param pfxlen  nr of flags in "pfxlist" for prefixes, rest is compound flags
 ///
 /// @return  FAIL when out of memory.
-static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffile_T *affile,
+static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_T *affile,
                           hashtab_T *ht, hashtab_T *xht, int condit, int flags, char *pfxlist,
                           int pfxlen)
 {
@@ -3525,16 +3514,18 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
               // Extract flags from the affix list.
               use_flags |= get_affix_flags(affile, ae->ae_flags);
 
-              if (affile->af_needaffix != 0 && flag_in_afflist(affile->af_flagtype, ae->ae_flags,
-                                                               affile->af_needaffix)) {
+              if (affile->af_needaffix != 0
+                  && flag_in_afflist(affile->af_flagtype, ae->ae_flags,
+                                     affile->af_needaffix)) {
                 need_affix = true;
               }
 
               // When there is a CIRCUMFIX flag the other affix
               // must also have it and we don't add the word
               // with one affix.
-              if (affile->af_circumfix != 0 && flag_in_afflist(affile->af_flagtype, ae->ae_flags,
-                                                               affile->af_circumfix)) {
+              if (affile->af_circumfix != 0
+                  && flag_in_afflist(affile->af_flagtype, ae->ae_flags,
+                                     affile->af_circumfix)) {
                 use_condit |= CONDIT_CFIX;
                 if ((condit & CONDIT_CFIX) == 0) {
                   need_affix = true;
@@ -3545,8 +3536,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
                   || spin->si_compflags != NULL) {
                 if (affile->af_pfxpostpone) {
                   // Get prefix IDS from the affix list.
-                  use_pfxlen = get_pfxlist(affile,
-                                           ae->ae_flags, store_afflist);
+                  use_pfxlen = get_pfxlist(affile, ae->ae_flags, store_afflist);
                 } else {
                   use_pfxlen = 0;
                 }
@@ -3567,7 +3557,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
 
                 if (spin->si_compflags != NULL) {
                   // Get compound IDS from the affix list.
-                  get_compflags(affile, (char *)ae->ae_flags,
+                  get_compflags(affile, ae->ae_flags,
                                 (char_u *)use_pfxlist + use_pfxlen);
                 } else {
                   use_pfxlist[use_pfxlen] = NUL;
@@ -3624,7 +3614,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
 
             // Store the modified word.
             if (store_word(spin, newword, use_flags,
-                           spin->si_region, (char_u *)use_pfxlist,
+                           spin->si_region, use_pfxlist,
                            need_affix) == FAIL) {
               retval = FAIL;
             }
@@ -3669,7 +3659,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
 }
 
 // Read a file with a list of words.
-static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
+static int spell_read_wordfile(spellinfo_T *spin, char *fname)
 {
   FILE *fd;
   long lnum = 0;
@@ -3685,7 +3675,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
   int regionmask;
 
   // Open the file.
-  fd = os_fopen((char *)fname, "r");
+  fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return FAIL;
@@ -3695,7 +3685,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
   spell_message(spin, IObuff);
 
   // Read all the lines in the file one by one.
-  while (!vim_fgets((char *)rline, MAXLINELEN, fd) && !got_int) {
+  while (!vim_fgets(rline, MAXLINELEN, fd) && !got_int) {
     line_breakcheck();
     lnum++;
 
@@ -3935,11 +3925,11 @@ static bool valid_spell_word(const char *word, const char *end)
 /// @param region  supported region(s)
 /// @param pfxlist  list of prefix ids or null
 /// @param need_affix  only store word with affix id
-static int store_word(spellinfo_T *spin, char *word, int flags, int region, const char_u *pfxlist,
+static int store_word(spellinfo_T *spin, char *word, int flags, int region, const char *pfxlist,
                       bool need_affix)
 {
   int len = (int)strlen(word);
-  int ct = captype((char_u *)word, (char_u *)word + len);
+  int ct = captype(word, word + len);
   char_u foldword[MAXWLEN];
   int res = OK;
 
@@ -3948,8 +3938,8 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
     return FAIL;
   }
 
-  (void)spell_casefold(curwin, (char_u *)word, len, foldword, MAXWLEN);
-  for (const char_u *p = pfxlist; res == OK; p++) {
+  (void)spell_casefold(curwin, word, len, (char *)foldword, MAXWLEN);
+  for (const char_u *p = (char_u *)pfxlist; res == OK; p++) {
     if (!need_affix || (p != NULL && *p != NUL)) {
       res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
                           region, p == NULL ? 0 : *p);
@@ -3961,7 +3951,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
   spin->si_foldwcount++;
 
   if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
-    for (const char_u *p = pfxlist; res == OK; p++) {
+    for (const char_u *p = (char_u *)pfxlist; res == OK; p++) {
       if (!need_affix || (p != NULL && *p != NUL)) {
         res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags,
                             region, p == NULL ? 0 : *p);
@@ -4974,7 +4964,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
   len = (int)strlen(fname);
   fname[len - 2] = 'u';
   fname[len - 1] = 'g';
-  sug_write(spin, (char_u *)fname);
+  sug_write(spin, fname);
 
 theend:
   xfree(fname);
@@ -5008,7 +4998,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
 
   // Go through the whole case-folded tree, soundfold each word and put it
   // in the trie.
-  byts = slang->sl_fbyts;
+  byts = (char_u *)slang->sl_fbyts;
   idxs = slang->sl_fidxs;
 
   arridx[0] = 0;
@@ -5199,10 +5189,10 @@ static int offset2bytes(int nr, char_u *buf)
 }
 
 // Write the .sug file in "fname".
-static void sug_write(spellinfo_T *spin, char_u *fname)
+static void sug_write(spellinfo_T *spin, char *fname)
 {
   // Create the file.  Note that an existing file is silently overwritten!
-  FILE *fd = os_fopen((char *)fname, "w");
+  FILE *fd = os_fopen(fname, "w");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return;
@@ -5284,7 +5274,7 @@ theend:
 /// @param added_word  invoked through "zg"
 static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool added_word)
 {
-  char_u *fname = NULL;
+  char *fname = NULL;
   char **innames;
   int incount;
   afffile_T *(afile[MAXREGIONS]);
@@ -5301,9 +5291,9 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
   ga_init(&spin.si_rep, (int)sizeof(fromto_T), 20);
   ga_init(&spin.si_repsal, (int)sizeof(fromto_T), 20);
   ga_init(&spin.si_sal, (int)sizeof(fromto_T), 20);
-  ga_init(&spin.si_map, (int)sizeof(char_u), 100);
-  ga_init(&spin.si_comppat, (int)sizeof(char_u *), 20);
-  ga_init(&spin.si_prefcond, (int)sizeof(char_u *), 50);
+  ga_init(&spin.si_map, (int)sizeof(char), 100);
+  ga_init(&spin.si_comppat, (int)sizeof(char *), 20);
+  ga_init(&spin.si_prefcond, (int)sizeof(char *), 50);
   hash_init(&spin.si_commonwords);
   spin.si_newcompID = 127;      // start compound ID at first maximum
 
@@ -5325,14 +5315,14 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       // For ":mkspell path/vim" output file is "path/vim.latin1.spl".
       incount = 1;
       vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
-                   fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
+                   fnames[0], spin.si_ascii ? "ascii" : spell_enc());
     } else if (len > 4 && strcmp(fnames[0] + len - 4, ".spl") == 0) {
       // Name ends in ".spl", use as the file name.
       xstrlcpy(wfname, fnames[0], MAXPATHL);
     } else {
       // Name should be language, make the file name from it.
       vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
-                   fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
+                   fnames[0], spin.si_ascii ? "ascii" : spell_enc());
     }
 
     // Check for .ascii.spl.
@@ -5404,8 +5394,8 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       spin.si_conv.vc_type = CONV_NONE;
       spin.si_region = 1 << i;
 
-      vim_snprintf((char *)fname, MAXPATHL, "%s.aff", innames[i]);
-      if (os_path_exists((char *)fname)) {
+      vim_snprintf(fname, MAXPATHL, "%s.aff", innames[i]);
+      if (os_path_exists(fname)) {
         // Read the .aff file.  Will init "spin->si_conv" based on the
         // "SET" line.
         afile[i] = spell_read_aff(&spin, fname);
@@ -5413,8 +5403,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
           error = true;
         } else {
           // Read the .dic file and store the words in the trees.
-          vim_snprintf((char *)fname, MAXPATHL, "%s.dic",
-                       innames[i]);
+          vim_snprintf(fname, MAXPATHL, "%s.dic", innames[i]);
           if (spell_read_dic(&spin, fname, afile[i]) == FAIL) {
             error = true;
           }
@@ -5422,7 +5411,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       } else {
         // No .aff file, try reading the file as a word list.  Store
         // the words in the trees.
-        if (spell_read_wordfile(&spin, (char_u *)innames[i]) == FAIL) {
+        if (spell_read_wordfile(&spin, innames[i]) == FAIL) {
           error = true;
         }
       }
@@ -5458,7 +5447,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
       // If the file is loaded need to reload it.
       if (!error) {
-        spell_reload_one((char_u *)wfname, added_word);
+        spell_reload_one(wfname, added_word);
       }
     }
 
@@ -5534,11 +5523,11 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
   buf_T *buf = NULL;
   bool new_spf = false;
   char *fname;
-  char_u *fnamebuf = NULL;
+  char *fnamebuf = NULL;
   char line[MAXWLEN * 2];
   long fpos, fpos_next = 0;
   int i;
-  char_u *spf;
+  char *spf;
 
   if (!valid_spell_word(word, word + len)) {
     emsg(_(e_illegal_character_in_word));
@@ -5547,12 +5536,12 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
 
   if (idx == 0) {           // use internal wordlist
     if (int_wordlist == NULL) {
-      int_wordlist = (char_u *)vim_tempname();
+      int_wordlist = vim_tempname();
       if (int_wordlist == NULL) {
         return;
       }
     }
-    fname = (char *)int_wordlist;
+    fname = int_wordlist;
   } else {
     // If 'spellfile' isn't set figure out a good default value.
     if (*curwin->w_s->b_p_spf == NUL) {
@@ -5566,8 +5555,8 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
     }
     fnamebuf = xmalloc(MAXPATHL);
 
-    for (spf = (char_u *)curwin->w_s->b_p_spf, i = 1; *spf != NUL; i++) {
-      copy_option_part((char **)&spf, (char *)fnamebuf, MAXPATHL, ",");
+    for (spf = curwin->w_s->b_p_spf, i = 1; *spf != NUL; i++) {
+      copy_option_part(&spf, fnamebuf, MAXPATHL, ",");
       if (i == idx) {
         break;
       }
@@ -5579,7 +5568,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
     }
 
     // Check that the user isn't editing the .add file somewhere.
-    buf = buflist_findname_exp((char *)fnamebuf);
+    buf = buflist_findname_exp(fnamebuf);
     if (buf != NULL && buf->b_ml.ml_mfp == NULL) {
       buf = NULL;
     }
@@ -5589,7 +5578,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
       return;
     }
 
-    fname = (char *)fnamebuf;
+    fname = fnamebuf;
   }
 
   if (what == SPELL_ADD_BAD || undo) {
@@ -5690,18 +5679,18 @@ static void init_spellfile(void)
 {
   char *buf;
   int l;
-  char_u *fname;
-  char_u *rtp;
-  char_u *lend;
+  char *fname;
+  char *rtp;
+  char *lend;
   bool aspath = false;
-  char_u *lstart = (char_u *)curbuf->b_s.b_p_spl;
+  char *lstart = curbuf->b_s.b_p_spl;
 
   if (*curwin->w_s->b_p_spl != NUL && !GA_EMPTY(&curwin->w_s->b_langp)) {
     buf = xmalloc(MAXPATHL);
 
     // Find the end of the language name.  Exclude the region.  If there
     // is a path separator remember the start of the tail.
-    for (lend = (char_u *)curwin->w_s->b_p_spl; *lend != NUL
+    for (lend = curwin->w_s->b_p_spl; *lend != NUL
          && vim_strchr(",._", (uint8_t)(*lend)) == NULL; lend++) {
       if (vim_ispathsep(*lend)) {
         aspath = true;
@@ -5711,21 +5700,21 @@ static void init_spellfile(void)
 
     // Loop over all entries in 'runtimepath'.  Use the first one where we
     // are allowed to write.
-    rtp = (char_u *)p_rtp;
+    rtp = p_rtp;
     while (*rtp != NUL) {
       if (aspath) {
         // Use directory of an entry with path, e.g., for
         // "/dir/lg.utf-8.spl" use "/dir".
-        xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(lstart - (char_u *)curbuf->b_s.b_p_spl));
+        xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(lstart - curbuf->b_s.b_p_spl));
       } else {
         // Copy the path from 'runtimepath' to buf[].
-        copy_option_part((char **)&rtp, buf, MAXPATHL, ",");
+        copy_option_part(&rtp, buf, MAXPATHL, ",");
       }
       if (os_file_is_writable(buf) == 2) {
         // Use the first language name from 'spelllang' and the
         // encoding used in the first loaded .spl file.
         if (aspath) {
-          xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(lend - (char_u *)curbuf->b_s.b_p_spl + 1));
+          xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(lend - curbuf->b_s.b_p_spl + 1));
         } else {
           // Create the "spell" directory if it doesn't exist yet.
           l = (int)strlen(buf);
@@ -5739,14 +5728,14 @@ static void init_spellfile(void)
                        "/%.*s", (int)(lend - lstart), lstart);
         }
         l = (int)strlen(buf);
-        fname = (char_u *)LANGP_ENTRY(curwin->w_s->b_langp, 0)
+        fname = LANGP_ENTRY(curwin->w_s->b_langp, 0)
                 ->lp_slang->sl_fname;
         vim_snprintf(buf + l, MAXPATHL - (size_t)l, ".%s.add",
                      ((fname != NULL
-                       && strstr(path_tail((char *)fname), ".ascii.") != NULL)
+                       && strstr(path_tail(fname), ".ascii.") != NULL)
                       ? "ascii"
                       : (const char *)spell_enc()));
-        set_option_value_give_err("spellfile", 0L, (const char *)buf, OPT_LOCAL);
+        set_option_value_give_err("spellfile", 0L, buf, OPT_LOCAL);
         break;
       }
       aspath = false;
@@ -5759,13 +5748,13 @@ static void init_spellfile(void)
 /// Set the spell character tables from strings in the .spl file.
 ///
 /// @param cnt  length of "flags"
-static void set_spell_charflags(const char_u *flags, int cnt, char_u *fol)
+static void set_spell_charflags(const char_u *flags, int cnt, char *fol)
 {
   // We build the new tables here first, so that we can compare with the
   // previous one.
   spelltab_T new_st;
   int i;
-  char *p = (char *)fol;
+  char *p = fol;
   int c;
 
   clear_spell_chartab(&new_st);
@@ -5843,7 +5832,7 @@ static int write_spell_prefcond(FILE *fd, garray_T *gap, size_t *fwv)
 }
 
 // Use map string "map" for languages "lp".
-static void set_map_str(slang_T *lp, char_u *map)
+static void set_map_str(slang_T *lp, char *map)
 {
   char *p;
   int headc = 0;
@@ -5865,7 +5854,7 @@ static void set_map_str(slang_T *lp, char_u *map)
   // The similar characters are stored separated with slashes:
   // "aaa/bbb/ccc/".  Fill sl_map_array[c] with the character before c and
   // before the same slash.  For characters above 255 sl_map_hash is used.
-  for (p = (char *)map; *p != NUL;) {
+  for (p = map; *p != NUL;) {
     c = mb_cptr2char_adv((const char **)&p);
     if (c == '/') {
       headc = 0;
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index c2888b3945..aa5e13d08a 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -304,7 +304,7 @@ static int score_wordcount_adj(slang_T *slang, int score, char_u *word, bool spl
 static int badword_captype(char_u *word, char_u *end)
   FUNC_ATTR_NONNULL_ALL
 {
-  int flags = captype(word, end);
+  int flags = captype((char *)word, (char *)end);
   int c;
   int l, u;
   bool first;
@@ -497,15 +497,15 @@ void spell_suggest(int count)
     line = get_cursor_line_ptr();
     p = (char_u *)line + curwin->w_cursor.col;
     // Backup to before start of word.
-    while (p > (char_u *)line && spell_iswordp_nmw(p, curwin)) {
+    while (p > (char_u *)line && spell_iswordp_nmw((char *)p, curwin)) {
       MB_PTR_BACK(line, p);
     }
     // Forward to start of word.
-    while (*p != NUL && !spell_iswordp_nmw(p, curwin)) {
+    while (*p != NUL && !spell_iswordp_nmw((char *)p, curwin)) {
       MB_PTR_ADV(p);
     }
 
-    if (!spell_iswordp_nmw(p, curwin)) {                // No word found.
+    if (!spell_iswordp_nmw((char *)p, curwin)) {                // No word found.
       beep_flush();
       return;
     }
@@ -678,13 +678,13 @@ void spell_suggest(int count)
 ///
 /// @param maxcount  maximum nr of suggestions
 /// @param need_cap  'spellcapcheck' matched
-void spell_suggest_list(garray_T *gap, char_u *word, int maxcount, bool need_cap, bool interactive)
+void spell_suggest_list(garray_T *gap, char *word, int maxcount, bool need_cap, bool interactive)
 {
   suginfo_T sug;
   suggest_T *stp;
   char_u *wcopy;
 
-  spell_find_suggest(word, 0, &sug, maxcount, false, need_cap, interactive);
+  spell_find_suggest((char_u *)word, 0, &sug, maxcount, false, need_cap, interactive);
 
   // Make room in "gap".
   ga_init(gap, sizeof(char_u *), sug.su_ga.ga_len + 1);
@@ -749,7 +749,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
     su->su_badlen = MAXWLEN - 1;        // just in case
   }
   xstrlcpy((char *)su->su_badword, su->su_badptr, (size_t)su->su_badlen + 1);
-  (void)spell_casefold(curwin, (char_u *)su->su_badptr, su->su_badlen, (char_u *)su->su_fbadword,
+  (void)spell_casefold(curwin, su->su_badptr, su->su_badlen, su->su_fbadword,
                        MAXWLEN);
 
   // TODO(vim): make this work if the case-folded text is longer than the
@@ -788,7 +788,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   // for that.
   c = utf_ptr2char(su->su_badptr);
   if (!SPELL_ISUPPER(c) && attr == HLF_COUNT) {
-    make_case_word((char_u *)su->su_badword, (char_u *)buf, WF_ONECAP);
+    make_case_word((char *)su->su_badword, buf, WF_ONECAP);
     add_suggestion(su, &su->su_ga, (char *)buf, su->su_badlen, SCORE_ICASE,
                    0, true, su->su_sallang, false);
   }
@@ -900,8 +900,8 @@ static void spell_suggest_file(suginfo_T *su, char_u *fname)
 
       // If the suggestion doesn't have specific case duplicate the case
       // of the bad word.
-      if (captype(p, NULL) == 0) {
-        make_case_word(p, cword, su->su_badflags);
+      if (captype((char *)p, NULL) == 0) {
+        make_case_word((char *)p, (char *)cword, su->su_badflags);
         p = cword;
       }
 
@@ -1021,7 +1021,7 @@ static void suggest_try_special(suginfo_T *su)
     // use that for the goodword too: "The the" -> "The".
     c = su->su_fbadword[len];
     su->su_fbadword[len] = NUL;
-    make_case_word((char_u *)su->su_fbadword, word, su->su_badflags);
+    make_case_word(su->su_fbadword, (char *)word, su->su_badflags);
     su->su_fbadword[len] = c;
 
     // Give a soundalike score of 0, compute the score as if deleting one
@@ -1090,7 +1090,7 @@ static void suggest_try_change(suginfo_T *su)
   STRCPY(fword, su->su_fbadword);
   n = (int)strlen(fword);
   p = su->su_badptr + su->su_badlen;
-  (void)spell_casefold(curwin, (char_u *)p, (int)strlen(p), (char_u *)fword + n, MAXWLEN - n);
+  (void)spell_casefold(curwin, p, (int)strlen(p), fword + n, MAXWLEN - n);
 
   // Make sure the resulting text is not longer than the original text.
   n = (int)strlen(su->su_badptr);
@@ -1198,7 +1198,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
 
   if (soundfold) {
     // Going through the soundfold tree.
-    byts = fbyts = slang->sl_sbyts;
+    byts = fbyts = (char_u *)slang->sl_sbyts;
     idxs = fidxs = slang->sl_sidxs;
     pbyts = NULL;
     pidxs = NULL;
@@ -1207,9 +1207,9 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
   } else {
     // When there are postponed prefixes we need to use these first.  At
     // the end of the prefix we continue in the case-fold tree.
-    fbyts = slang->sl_fbyts;
+    fbyts = (char_u *)slang->sl_fbyts;
     fidxs = slang->sl_fidxs;
-    pbyts = slang->sl_pbyts;
+    pbyts = (char_u *)slang->sl_pbyts;
     pidxs = slang->sl_pidxs;
     if (pbyts != NULL) {
       byts = pbyts;
@@ -1263,7 +1263,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
         if (depth < MAXWLEN - 1 && (byts[arridx] == 0 || n == STATE_NOPREFIX)) {
           // Set su->su_badflags to the caps type at this position.
           // Use the caps type until here for the prefix itself.
-          n = nofold_len((char_u *)fword, sp->ts_fidx, (char_u *)su->su_badptr);
+          n = nofold_len(fword, sp->ts_fidx, su->su_badptr);
           flags = badword_captype((char_u *)su->su_badptr, (char_u *)su->su_badptr + n);
           su->su_badflags = badword_captype((char_u *)su->su_badptr + n,
                                             (char_u *)su->su_badptr + su->su_badlen);
@@ -1281,8 +1281,8 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
           // Move the prefix to preword[] with the right case
           // and make find_keepcap_word() works.
           tword[sp->ts_twordlen] = NUL;
-          make_case_word((char_u *)tword + sp->ts_splitoff,
-                         (char_u *)preword + sp->ts_prewordlen, flags);
+          make_case_word(tword + sp->ts_splitoff,
+                         preword + sp->ts_prewordlen, flags);
           sp->ts_prewordlen = (char_u)strlen(preword);
           sp->ts_splitoff = sp->ts_twordlen;
         }
@@ -1310,7 +1310,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
       fword_ends = (fword[sp->ts_fidx] == NUL
                     || (soundfold
                         ? ascii_iswhite(fword[sp->ts_fidx])
-                        : !spell_iswordp((char_u *)fword + sp->ts_fidx, curwin)));
+                        : !spell_iswordp(fword + sp->ts_fidx, curwin)));
       tword[sp->ts_twordlen] = NUL;
 
       if (sp->ts_prefixdepth <= PFD_NOTSPECIAL
@@ -1325,7 +1325,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
         for (c = 0; c < len && pbyts[n + c] == 0; c++) {}
         if (c > 0) {
           c = valid_word_prefix(c, n, flags,
-                                (char_u *)tword + sp->ts_splitoff, slang, false);
+                                tword + sp->ts_splitoff, slang, false);
           if (c == 0) {
             break;
           }
@@ -1446,11 +1446,11 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
 
         // When appending a compound word after a word character don't
         // use Onecap.
-        if (p != NULL && spell_iswordp_nmw((char_u *)p, curwin)) {
+        if (p != NULL && spell_iswordp_nmw(p, curwin)) {
           c &= ~WF_ONECAP;
         }
-        make_case_word((char_u *)tword + sp->ts_splitoff,
-                       (char_u *)preword + sp->ts_prewordlen, c);
+        make_case_word(tword + sp->ts_splitoff,
+                       preword + sp->ts_prewordlen, c);
       }
 
       if (!soundfold) {
@@ -1482,7 +1482,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
         }
 
         if (!spell_valid_case(su->su_badflags,
-                              captype((char_u *)preword + sp->ts_prewordlen, NULL))) {
+                              captype(preword + sp->ts_prewordlen, NULL))) {
           newscore += SCORE_ICASE;
         }
       }
@@ -1513,10 +1513,10 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
           // char, e.g., "thes," -> "these".
           p = fword + sp->ts_fidx;
           MB_PTR_BACK(fword, p);
-          if (!spell_iswordp((char_u *)p, curwin) && *preword != NUL) {
+          if (!spell_iswordp(p, curwin) && *preword != NUL) {
             p = preword + strlen(preword);
             MB_PTR_BACK(preword, p);
-            if (spell_iswordp((char_u *)p, curwin)) {
+            if (spell_iswordp(p, curwin)) {
               newscore += SCORE_NONWORD;
             }
           }
@@ -1536,10 +1536,10 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
             if (su->su_badflags & WF_MIXCAP) {
               // We really don't know if the word should be
               // upper or lower case, add both.
-              c = captype((char_u *)preword, NULL);
+              c = captype(preword, NULL);
               if (c == 0 || c == WF_ALLCAP) {
-                make_case_word((char_u *)tword + sp->ts_splitoff,
-                               (char_u *)preword + sp->ts_prewordlen,
+                make_case_word(tword + sp->ts_splitoff,
+                               preword + sp->ts_prewordlen,
                                c == 0 ? WF_ALLCAP : 0);
 
                 add_suggestion(su, &su->su_ga, (char *)preword,
@@ -1678,7 +1678,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
             // non-word character with a space.  Always skip a
             // character when the word ends.  But only when the
             // good word can end.
-            if (((!try_compound && !spell_iswordp_nmw((char_u *)fword
+            if (((!try_compound && !spell_iswordp_nmw(fword
                                                       + sp->ts_fidx,
                                                       curwin))
                  || fword_ends)
@@ -1710,7 +1710,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
 
             // set su->su_badflags to the caps type at this
             // position
-            n = nofold_len((char_u *)fword, sp->ts_fidx, (char_u *)su->su_badptr);
+            n = nofold_len(fword, sp->ts_fidx, su->su_badptr);
             su->su_badflags = badword_captype((char_u *)su->su_badptr + n,
                                               (char_u *)su->su_badptr + su->su_badlen);
 
@@ -2034,7 +2034,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
 
       // Don't swap if the first character is not a word character.
       // SWAP3 etc. also don't make sense then.
-      if (!soundfold && !spell_iswordp((char_u *)p, curwin)) {
+      if (!soundfold && !spell_iswordp(p, curwin)) {
         PROF_STORE(sp->ts_state)
         sp->ts_state = STATE_REP_INI;
         break;
@@ -2044,7 +2044,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
       c = utf_ptr2char(p);
       if (p[n] == NUL) {
         c2 = NUL;
-      } else if (!soundfold && !spell_iswordp((char_u *)p + n, curwin)) {
+      } else if (!soundfold && !spell_iswordp(p + n, curwin)) {
         c2 = c;  // don't swap non-word char
       } else {
         c2 = utf_ptr2char(p + n);
@@ -2104,7 +2104,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
       c = utf_ptr2char(p);
       fl = utf_ptr2len(p + n);
       c2 = utf_ptr2char(p + n);
-      if (!soundfold && !spell_iswordp((char_u *)p + n + fl, curwin)) {
+      if (!soundfold && !spell_iswordp(p + n + fl, curwin)) {
         c3 = c;  // don't swap non-word char
       } else {
         c3 = utf_ptr2char(p + n + fl);
@@ -2155,7 +2155,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
       utf_char2bytes(c2, p + tl);
       p = p + tl;
 
-      if (!soundfold && !spell_iswordp((char_u *)p, curwin)) {
+      if (!soundfold && !spell_iswordp(p, curwin)) {
         // Middle char is not a word char, skip the rotate.  First and
         // third char were already checked at swap and swap3.
         PROF_STORE(sp->ts_state)
@@ -2399,7 +2399,7 @@ static void find_keepcap_word(slang_T *slang, char *fword, char *kword)
   int c;
   idx_T lo, hi, m;
   char_u *p;
-  char_u *byts = slang->sl_kbyts;      // array with bytes of the words
+  char_u *byts = (char_u *)slang->sl_kbyts;      // array with bytes of the words
   idx_T *idxs = slang->sl_kidxs;      // array with indexes
 
   if (byts == NULL) {
@@ -2409,7 +2409,7 @@ static void find_keepcap_word(slang_T *slang, char *fword, char *kword)
   }
 
   // Make an all-cap version of "fword".
-  allcap_copy((char_u *)fword, (char_u *)uword);
+  allcap_copy(fword, uword);
 
   // Each character needs to be tried both case-folded and upper-case.
   // All this gets very complicated if we keep in mind that changing case
@@ -2666,7 +2666,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
     pbad = badsound;
   } else {
     // soundfold the bad word with more characters following
-    (void)spell_casefold(curwin, (char_u *)su->su_badptr, stp->st_orglen, fword, MAXWLEN);
+    (void)spell_casefold(curwin, su->su_badptr, stp->st_orglen, (char *)fword, MAXWLEN);
 
     // When joining two words the sound often changes a lot.  E.g., "t he"
     // sounds like "t h" while "the" sounds like "@".  Avoid that by
@@ -2851,7 +2851,7 @@ static void add_sound_suggest(suginfo_T *su, char *goodword, int score, langp_T
     // previous wordnr.
     orgnr += bytes2offset(&nrline);
 
-    byts = slang->sl_fbyts;
+    byts = (char_u *)slang->sl_fbyts;
     idxs = slang->sl_fidxs;
 
     // Lookup the word "orgnr" one of the two tries.
@@ -2909,7 +2909,7 @@ badword:
         flags |= su->su_badflags;
         if ((flags & WF_CAPMASK) != 0) {
           // Need to fix case according to "flags".
-          make_case_word(theword, cword, flags);
+          make_case_word((char *)theword, (char *)cword, flags);
           p = cword;
         } else {
           p = theword;
@@ -2989,7 +2989,7 @@ static int soundfold_find(slang_T *slang, char_u *word)
   idx_T *idxs;
   int wordnr = 0;
 
-  byts = slang->sl_sbyts;
+  byts = (char_u *)slang->sl_sbyts;
   idxs = slang->sl_sidxs;
 
   for (;;) {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index f18f445867..78f650ab76 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -3416,8 +3416,8 @@ static void syn_list_one(const int id, const bool syncing, const bool link_only)
       }
       msg_putchar(' ');
       if (spp->sp_sync_idx >= 0) {
-        msg_outtrans((char *)highlight_group_name(SYN_ITEMS(curwin->w_s)
-                                                  [spp->sp_sync_idx].sp_syn.id - 1));
+        msg_outtrans(highlight_group_name(SYN_ITEMS(curwin->w_s)
+                                          [spp->sp_sync_idx].sp_syn.id - 1));
       } else {
         msg_puts("NONE");
       }
@@ -3430,7 +3430,7 @@ static void syn_list_one(const int id, const bool syncing, const bool link_only)
     (void)syn_list_header(did_header, 0, id, true);
     msg_puts_attr("links to", attr);
     msg_putchar(' ');
-    msg_outtrans((char *)highlight_group_name(highlight_link_id(id - 1) - 1));
+    msg_outtrans(highlight_group_name(highlight_link_id(id - 1) - 1));
   }
 }
 
@@ -3492,7 +3492,7 @@ static void put_id_list(const char *const name, const int16_t *const list, const
       msg_putchar('@');
       msg_outtrans((char *)SYN_CLSTR(curwin->w_s)[scl_id].scl_name);
     } else {
-      msg_outtrans((char *)highlight_group_name(*p - 1));
+      msg_outtrans(highlight_group_name(*p - 1));
     }
     if (p[1]) {
       msg_putchar(',');
@@ -3514,7 +3514,7 @@ static void put_pattern(const char *const s, const int c, const synpat_T *const
     if (last_matchgroup == 0) {
       msg_outtrans("NONE");
     } else {
-      msg_outtrans((char *)highlight_group_name(last_matchgroup - 1));
+      msg_outtrans(highlight_group_name(last_matchgroup - 1));
     }
     msg_putchar(' ');
   }
@@ -5042,7 +5042,7 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
           regmatch.rm_ic = true;
           id = 0;
           for (int i = highlight_num_groups(); --i >= 0;) {
-            if (vim_regexec(&regmatch, (char *)highlight_group_name(i), (colnr_T)0)) {
+            if (vim_regexec(&regmatch, highlight_group_name(i), (colnr_T)0)) {
               if (round == 2) {
                 // Got more items than expected; can happen
                 // when adding items that match:
@@ -5677,7 +5677,7 @@ static void syntime_report(void)
     msg_puts(profile_msg(p->average));
     msg_puts(" ");
     msg_advance(50);
-    msg_outtrans((char *)highlight_group_name(p->id - 1));
+    msg_outtrans(highlight_group_name(p->id - 1));
     msg_puts(" ");
 
     msg_advance(69);