refactor: remove char_u (#22829)

Closes https://github.com/neovim/neovim/issues/459

25 files changed, 313 insertions, 317 deletions

diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 63459495f8..2be8ccc456 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -55,7 +55,7 @@ static bool chartab_initialized = false;
   ((chartab)[(unsigned)(c) >> 6] & (1ull << ((c) & 0x3f)))
 
 // Table used below, see init_chartab() for an explanation
-static char_u g_chartab[256];
+static uint8_t g_chartab[256];
 
 // Flags for g_chartab[].
 #define CT_CELL_MASK  0x07  ///< mask: nr of display cells (1, 2 or 4)
@@ -286,7 +286,7 @@ void trans_characters(char *buf, int bufsize)
     if ((trs_len = utfc_ptr2len(buf)) > 1) {
       len -= trs_len;
     } else {
-      trs = (char *)transchar_byte((uint8_t)(*buf));
+      trs = transchar_byte((uint8_t)(*buf));
       trs_len = (int)strlen(trs);
 
       if (trs_len > 1) {
@@ -532,7 +532,7 @@ char *str_foldcase(char *str, int orglen, char *buf, int buflen)
 // Does NOT work for multi-byte characters, c must be <= 255.
 // Also doesn't work for the first byte of a multi-byte, "c" must be a
 // character!
-static char_u transchar_charbuf[11];
+static uint8_t transchar_charbuf[11];
 
 /// Translate a character into a printable one, leaving printable ASCII intact
 ///
@@ -543,10 +543,10 @@ static char_u transchar_charbuf[11];
 /// @return translated character into a static buffer.
 char *transchar(int c)
 {
-  return (char *)transchar_buf(curbuf, c);
+  return transchar_buf(curbuf, c);
 }
 
-char_u *transchar_buf(const buf_T *buf, int c)
+char *transchar_buf(const buf_T *buf, int c)
 {
   int i = 0;
   if (IS_SPECIAL(c)) {
@@ -560,14 +560,14 @@ char_u *transchar_buf(const buf_T *buf, int c)
   if ((!chartab_initialized && (c >= ' ' && c <= '~'))
       || ((c <= 0xFF) && vim_isprintc_strict(c))) {
     // printable character
-    transchar_charbuf[i] = (char_u)c;
+    transchar_charbuf[i] = (uint8_t)c;
     transchar_charbuf[i + 1] = NUL;
   } else if (c <= 0xFF) {
-    transchar_nonprint(buf, transchar_charbuf + i, c);
+    transchar_nonprint(buf, (char *)transchar_charbuf + i, c);
   } else {
     transchar_hex((char *)transchar_charbuf + i, c);
   }
-  return transchar_charbuf;
+  return (char *)transchar_charbuf;
 }
 
 /// Like transchar(), but called with a byte instead of a character.
@@ -577,7 +577,7 @@ char_u *transchar_buf(const buf_T *buf, int c)
 /// @param[in]  c  Byte to translate.
 ///
 /// @return pointer to translated character in transchar_charbuf.
-char_u *transchar_byte(const int c)
+char *transchar_byte(const int c)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   return transchar_byte_buf(curbuf, c);
@@ -590,12 +590,12 @@ char_u *transchar_byte(const int c)
 /// @param[in]  c  Byte to translate.
 ///
 /// @return pointer to translated character in transchar_charbuf.
-char_u *transchar_byte_buf(const buf_T *buf, const int c)
+char *transchar_byte_buf(const buf_T *buf, const int c)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if (c >= 0x80) {
-    transchar_nonprint(buf, transchar_charbuf, c);
-    return transchar_charbuf;
+    transchar_nonprint(buf, (char *)transchar_charbuf, c);
+    return (char *)transchar_charbuf;
   }
   return transchar_buf(buf, c);
 }
@@ -609,7 +609,7 @@ char_u *transchar_byte_buf(const buf_T *buf, const int c)
 ///                       at least 5 bytes (conversion result + NUL).
 /// @param[in]  c  Character to convert. NUL is assumed to be NL according to
 ///                `:h NL-used-for-NUL`.
-void transchar_nonprint(const buf_T *buf, char_u *charbuf, int c)
+void transchar_nonprint(const buf_T *buf, char *charbuf, int c)
 {
   if (c == NL) {
     // we use newline in place of a NUL
@@ -622,12 +622,12 @@ void transchar_nonprint(const buf_T *buf, char_u *charbuf, int c)
 
   if (dy_flags & DY_UHEX || c > 0x7f) {
     // 'display' has "uhex"
-    transchar_hex((char *)charbuf, c);
+    transchar_hex(charbuf, c);
   } else {
     // 0x00 - 0x1f and 0x7f
     charbuf[0] = '^';
     // DEL displayed as ^?
-    charbuf[1] = (char_u)(c ^ 0x40);
+    charbuf[1] = (char)(uint8_t)(c ^ 0x40);
 
     charbuf[2] = NUL;
   }
diff --git a/src/nvim/charset.h b/src/nvim/charset.h
index e1ef06ef1d..f98ed94b87 100644
--- a/src/nvim/charset.h
+++ b/src/nvim/charset.h
@@ -54,6 +54,6 @@ static inline bool vim_isbreak(int c)
 /// Used very often if 'linebreak' is set
 static inline bool vim_isbreak(int c)
 {
-  return breakat_flags[(char_u)c];
+  return breakat_flags[(uint8_t)c];
 }
 #endif  // NVIM_CHARSET_H
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 6d8cf1c7e1..caad88c212 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -2371,7 +2371,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           mb_c = c;
           mb_utf8 = check_mb_utf8(&c, u8cc);
         } else if (c != NUL) {
-          wlv.p_extra = (char *)transchar_buf(wp->w_buffer, c);
+          wlv.p_extra = transchar_buf(wp->w_buffer, c);
           if (wlv.n_extra == 0) {
             wlv.n_extra = byte2cells(c) - 1;
           }
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 26101d06ed..c551ec2726 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1955,7 +1955,7 @@ static void insert_special(int c, int allow_modmask, int ctrlv)
     allow_modmask = true;
   }
   if (IS_SPECIAL(c) || (mod_mask && allow_modmask)) {
-    char *p = (char *)get_special_key_name(c, mod_mask);
+    char *p = get_special_key_name(c, mod_mask);
     int len = (int)strlen(p);
     c = (uint8_t)p[len - 1];
     if (len > 2) {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 25d383d8ea..4286e16eb1 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -6197,7 +6197,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 # else
   char *v = os_realpath(fname, NULL);
-  rettv->vval.v_string = (char_u *)(v == NULL ? xstrdup(fname) : v);
+  rettv->vval.v_string = v == NULL ? xstrdup(fname) : v;
 # endif
 #endif
 
diff --git a/src/nvim/eval/typval_defs.h b/src/nvim/eval/typval_defs.h
index 4615198441..80432271b0 100644
--- a/src/nvim/eval/typval_defs.h
+++ b/src/nvim/eval/typval_defs.h
@@ -206,7 +206,7 @@ typedef struct {
   struct { \
     typval_T di_tv;  /* Structure that holds scope dictionary itself. */ \
     uint8_t di_flags;  /* Flags. */ \
-    char_u di_key[__VA_ARGS__];  /* Key value. */  /* NOLINT(runtime/arrays)*/ \
+    char di_key[__VA_ARGS__];  /* Key value. */  /* NOLINT(runtime/arrays)*/ \
   }
 
 /// Structure to hold a scope dictionary
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 13779f4173..40bca9acc1 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -90,7 +90,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int *
   bool mustend = false;
   char *arg = *argp;
   char *p = arg;
-  char_u c;
+  uint8_t c;
   int i;
 
   if (newargs != NULL) {
@@ -128,7 +128,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int *
       }
       if (newargs != NULL) {
         ga_grow(newargs, 1);
-        c = (char_u)(*p);
+        c = (uint8_t)(*p);
         *p = NUL;
         arg = xstrdup(arg);
 
@@ -159,7 +159,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int *
           while (p > expr && ascii_iswhite(p[-1])) {
             p--;
           }
-          c = (char_u)(*p);
+          c = (uint8_t)(*p);
           *p = NUL;
           expr = xstrdup(expr);
           ((char **)(default_args->ga_data))[default_args->ga_len] = expr;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 621cb764f4..705f0fe83d 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -149,7 +149,7 @@ void do_ascii(const exarg_T *const eap)
     char buf1[20];
     if (vim_isprintc_strict(c) && (c < ' ' || c > '~')) {
       char buf3[7];
-      transchar_nonprint(curbuf, (char_u *)buf3, c);
+      transchar_nonprint(curbuf, buf3, c);
       vim_snprintf(buf1, sizeof(buf1), "  <%s>", (char *)buf3);
     } else {
       buf1[0] = NUL;
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 5112505eda..bd7ddbf567 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -2117,7 +2117,7 @@ static int command_line_handle_key(CommandLineState *s)
 
   // put the character in the command line
   if (IS_SPECIAL(s->c) || mod_mask != 0) {
-    put_on_cmdline((char *)get_special_key_name(s->c, mod_mask), -1, true);
+    put_on_cmdline(get_special_key_name(s->c, mod_mask), -1, true);
   } else {
     int j = utf_char2bytes(s->c, IObuff);
     IObuff[j] = NUL;                // exclude composing chars
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index e27c7c4349..d91e2dfeeb 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -794,7 +794,7 @@ char *vim_findfile(void *search_ctx_arg)
                   ) {
 #ifdef FF_VERBOSE
                 if (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                     file_path, (char_u *)"") == FAIL) {
+                                     file_path, "") == FAIL) {
                   if (p_verbose >= 5) {
                     verbose_enter_scroll();
                     smsg("Already: %s", file_path);
diff --git a/src/nvim/generators/gen_ex_cmds.lua b/src/nvim/generators/gen_ex_cmds.lua
index 935d7b333e..26edd33604 100644
--- a/src/nvim/generators/gen_ex_cmds.lua
+++ b/src/nvim/generators/gen_ex_cmds.lua
@@ -41,7 +41,7 @@ static const uint16_t cmdidxs1[%u] = {
 -- Values in cmdidxs2[c1][c2] are relative to cmdidxs1[c1] so that they
 -- fit in a byte.
 local cmdidxs2_out = string.format([[
-static const char_u cmdidxs2[%u][%u] = {
+static const uint8_t cmdidxs2[%u][%u] = {
   /*           a   b   c   d   e   f   g   h   i   j   k   l   m   n   o   p   q   r   s   t   u   v   w   x   y   z */
 ]], a_to_z, a_to_z)
 
diff --git a/src/nvim/generators/gen_options.lua b/src/nvim/generators/gen_options.lua
index edb7dae159..54b97c5286 100644
--- a/src/nvim/generators/gen_options.lua
+++ b/src/nvim/generators/gen_options.lua
@@ -139,7 +139,7 @@ local dump_option = function(i, o)
     w(get_cond(o.enable_if))
   end
   if o.varname then
-    w('    .var=(char_u *)&' .. o.varname)
+    w('    .var=(char *)&' .. o.varname)
   elseif #o.scope == 1 and o.scope[1] == 'window' then
     w('    .var=VAR_WIN')
   end
diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index f3d379c2e9..8eec9014f7 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -34,18 +34,18 @@
 static const struct modmasktable {
   uint16_t mod_mask;  ///< Bit-mask for particular key modifier.
   uint16_t mod_flag;  ///< Bit(s) for particular key modifier.
-  char_u name;  ///< Single letter name of modifier.
+  char name;  ///< Single letter name of modifier.
 } mod_mask_table[] = {
-  { MOD_MASK_ALT,              MOD_MASK_ALT,           (char_u)'M' },
-  { MOD_MASK_META,             MOD_MASK_META,          (char_u)'T' },
-  { MOD_MASK_CTRL,             MOD_MASK_CTRL,          (char_u)'C' },
-  { MOD_MASK_SHIFT,            MOD_MASK_SHIFT,         (char_u)'S' },
-  { MOD_MASK_MULTI_CLICK,      MOD_MASK_2CLICK,        (char_u)'2' },
-  { MOD_MASK_MULTI_CLICK,      MOD_MASK_3CLICK,        (char_u)'3' },
-  { MOD_MASK_MULTI_CLICK,      MOD_MASK_4CLICK,        (char_u)'4' },
-  { MOD_MASK_CMD,              MOD_MASK_CMD,           (char_u)'D' },
+  { MOD_MASK_ALT,              MOD_MASK_ALT,           'M' },
+  { MOD_MASK_META,             MOD_MASK_META,          'T' },
+  { MOD_MASK_CTRL,             MOD_MASK_CTRL,          'C' },
+  { MOD_MASK_SHIFT,            MOD_MASK_SHIFT,         'S' },
+  { MOD_MASK_MULTI_CLICK,      MOD_MASK_2CLICK,        '2' },
+  { MOD_MASK_MULTI_CLICK,      MOD_MASK_3CLICK,        '3' },
+  { MOD_MASK_MULTI_CLICK,      MOD_MASK_4CLICK,        '4' },
+  { MOD_MASK_CMD,              MOD_MASK_CMD,           'D' },
   // 'A' must be the last one
-  { MOD_MASK_ALT,              MOD_MASK_ALT,           (char_u)'A' },
+  { MOD_MASK_ALT,              MOD_MASK_ALT,           'A' },
   { 0, 0, NUL }
   // NOTE: when adding an entry, update MAX_KEY_NAME_LEN!
 };
@@ -386,7 +386,7 @@ int name_to_mod_mask(int c)
 {
   c = TOUPPER_ASC(c);
   for (size_t i = 0; mod_mask_table[i].mod_mask != 0; i++) {
-    if (c == mod_mask_table[i].name) {
+    if (c == (uint8_t)mod_mask_table[i].name) {
       return mod_mask_table[i].mod_flag;
     }
   }
@@ -468,9 +468,9 @@ int handle_x_keys(const int key)
 }
 
 /// @return  a string which contains the name of the given key when the given modifiers are down.
-char_u *get_special_key_name(int c, int modifiers)
+char *get_special_key_name(int c, int modifiers)
 {
-  static char_u string[MAX_KEY_NAME_LEN + 1];
+  static char string[MAX_KEY_NAME_LEN + 1];
 
   int i, idx;
   int table_idx;
@@ -524,7 +524,7 @@ char_u *get_special_key_name(int c, int modifiers)
     if ((modifiers & mod_mask_table[i].mod_mask)
         == mod_mask_table[i].mod_flag) {
       string[idx++] = mod_mask_table[i].name;
-      string[idx++] = (char_u)'-';
+      string[idx++] = '-';
     }
   }
 
@@ -532,18 +532,18 @@ char_u *get_special_key_name(int c, int modifiers)
     if (IS_SPECIAL(c)) {
       string[idx++] = 't';
       string[idx++] = '_';
-      string[idx++] = (char_u)KEY2TERMCAP0(c);
-      string[idx++] = KEY2TERMCAP1(c);
+      string[idx++] = (char)(uint8_t)KEY2TERMCAP0(c);
+      string[idx++] = (char)(uint8_t)KEY2TERMCAP1(c);
     } else {
       // Not a special key, only modifiers, output directly.
       if (utf_char2len(c) > 1) {
-        idx += utf_char2bytes(c, (char *)string + idx);
+        idx += utf_char2bytes(c, string + idx);
       } else if (vim_isprintc(c)) {
-        string[idx++] = (char_u)c;
+        string[idx++] = (char)(uint8_t)c;
       } else {
         s = transchar(c);
         while (*s) {
-          string[idx++] = (uint8_t)(*s++);
+          string[idx++] = *s++;
         }
       }
     }
@@ -1083,7 +1083,7 @@ char *vim_strsave_escape_ks(char *p)
 /// vim_strsave_escape_ks().  Works in-place.
 void vim_unescape_ks(char *p)
 {
-  char_u *s = (char_u *)p, *d = (char_u *)p;
+  uint8_t *s = (uint8_t *)p, *d = (uint8_t *)p;
 
   while (*s != NUL) {
     if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER) {
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 5cedc5e97d..2941d5965b 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -1189,7 +1189,7 @@ static char *translate_mapping(char *str_in, int cpo_flags)
         str += 2;
       }
       if (IS_SPECIAL(c) || modifiers) {         // special key
-        ga_concat(&ga, (char *)get_special_key_name(c, modifiers));
+        ga_concat(&ga, get_special_key_name(c, modifiers));
         continue;         // for (str)
       }
     }
@@ -1436,7 +1436,7 @@ int ExpandMappings(char *pat, regmatch_T *regmatch, int *numMatches, char ***mat
 bool check_abbr(int c, char *ptr, int col, int mincol)
 {
   int scol;                     // starting column of the abbr.
-  char_u tb[MB_MAXBYTES + 4];
+  uint8_t tb[MB_MAXBYTES + 4];
   mapblock_T *mp;
   mapblock_T *mp2;
   int clen = 0;                 // length in characters
@@ -1535,8 +1535,8 @@ bool check_abbr(int c, char *ptr, int col, int mincol)
         // special key code, split up
         if (IS_SPECIAL(c) || c == K_SPECIAL) {
           tb[j++] = K_SPECIAL;
-          tb[j++] = (char_u)K_SECOND(c);
-          tb[j++] = (char_u)K_THIRD(c);
+          tb[j++] = (uint8_t)K_SECOND(c);
+          tb[j++] = (uint8_t)K_THIRD(c);
         } else {
           if (c < ABBR_OFF && (c < ' ' || c > '~')) {
             tb[j++] = Ctrl_V;                   // special char needs CTRL-V
@@ -1918,7 +1918,7 @@ int put_escstr(FILE *fd, char *strstart, int what)
         str += 2;
       }
       if (IS_SPECIAL(c) || modifiers) {         // special key
-        if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0) {
+        if (fputs(get_special_key_name(c, modifiers), fd) < 0) {
           return FAIL;
         }
         continue;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index fb52a11025..c580dc29e6 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -653,32 +653,32 @@ int utf_ptr2char(const char *const p_in)
 //
 // If byte sequence is illegal or incomplete, returns -1 and does not advance
 // "s".
-static int utf_safe_read_char_adv(const char_u **s, size_t *n)
+static int utf_safe_read_char_adv(const char **s, size_t *n)
 {
   if (*n == 0) {  // end of buffer
     return 0;
   }
 
-  uint8_t k = utf8len_tab_zero[**s];
+  uint8_t k = utf8len_tab_zero[(uint8_t)(**s)];
 
   if (k == 1) {
     // ASCII character or NUL
     (*n)--;
-    return *(*s)++;
+    return (uint8_t)(*(*s)++);
   }
 
   if (k <= *n) {
     // We have a multibyte sequence and it isn't truncated by buffer
     // limits so utf_ptr2char() is safe to use. Or the first byte is
     // illegal (k=0), and it's also safe to use utf_ptr2char().
-    int c = utf_ptr2char((char *)(*s));
+    int c = utf_ptr2char(*s);
 
     // On failure, utf_ptr2char() returns the first byte, so here we
     // check equality with the first byte. The only non-ASCII character
     // which equals the first byte of its own UTF-8 representation is
     // U+00C3 (UTF-8: 0xC3 0x83), so need to check that special case too.
     // It's safe even if n=1, else we would have k=2 > n.
-    if (c != (int)(**s) || (c == 0xC3 && (*s)[1] == 0x83)) {
+    if (c != (int)((uint8_t)(**s)) || (c == 0xC3 && (uint8_t)(*s)[1] == 0x83)) {
       // byte sequence was successfully decoded
       *s += k;
       *n -= k;
@@ -1271,7 +1271,7 @@ bool mb_isalpha(int a)
   return mb_islower(a) || mb_isupper(a);
 }
 
-static int utf_strnicmp(const char_u *s1, const char_u *s2, size_t n1, size_t n2)
+static int utf_strnicmp(const char *s1, const char *s2, size_t n1, size_t n2)
 {
   int c1, c2, cdiff;
   char buffer[6];
@@ -1313,14 +1313,14 @@ static int utf_strnicmp(const char_u *s1, const char_u *s2, size_t n1, size_t n2
 
   if (c1 != -1 && c2 == -1) {
     n1 = (size_t)utf_char2bytes(utf_fold(c1), (char *)buffer);
-    s1 = (char_u *)buffer;
+    s1 = buffer;
   } else if (c2 != -1 && c1 == -1) {
     n2 = (size_t)utf_char2bytes(utf_fold(c2), (char *)buffer);
-    s2 = (char_u *)buffer;
+    s2 = buffer;
   }
 
   while (n1 > 0 && n2 > 0 && *s1 != NUL && *s2 != NUL) {
-    cdiff = (int)(*s1) - (int)(*s2);
+    cdiff = (int)((uint8_t)(*s1)) - (int)((uint8_t)(*s2));
     if (cdiff != 0) {
       return cdiff;
     }
@@ -1498,7 +1498,7 @@ ssize_t mb_utf_index_to_bytes(const char *s, size_t len, size_t index, bool use_
 ///          two characters otherwise.
 int mb_strnicmp(const char *s1, const char *s2, const size_t nn)
 {
-  return utf_strnicmp((char_u *)s1, (char_u *)s2, nn, nn);
+  return utf_strnicmp(s1, s2, nn, nn);
 }
 
 /// Compare strings case-insensitively
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 0f2790b06c..51a4186775 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -351,7 +351,7 @@ int ml_open(buf_T *buf)
   dp->db_index[0] = --dp->db_txt_start;         // at end of block
   dp->db_free -= 1 + (unsigned)INDEX_SIZE;
   dp->db_line_count = 1;
-  *((char_u *)dp + dp->db_txt_start) = NUL;     // empty line
+  *((char *)dp + dp->db_txt_start) = NUL;     // empty line
 
   return OK;
 
@@ -1065,7 +1065,7 @@ void ml_recover(bool checkext)
           }
 
           // make sure there is a NUL at the end of the block
-          *((char_u *)dp + dp->db_txt_end - 1) = NUL;
+          *((char *)dp + dp->db_txt_end - 1) = NUL;
 
           // check number of lines in block
           // if wrong, use count in data block
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 98ef6e5cba..b43bc6ce9b 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1589,7 +1589,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
       len -= mb_l - 1;
       str += mb_l;
     } else {
-      s = (char *)transchar_byte_buf(NULL, (uint8_t)(*str));
+      s = transchar_byte_buf(NULL, (uint8_t)(*str));
       if (s[1] != NUL) {
         // Unprintable char: print the printable chars so far and the
         // translation of the unprintable char.
@@ -1671,7 +1671,7 @@ int msg_outtrans_special(const char *strstart, bool from, int maxlen)
     }
     if (text[0] != NUL && text[1] == NUL) {
       // single-byte character or illegal byte
-      text = (char *)transchar_byte_buf(NULL, (uint8_t)text[0]);
+      text = transchar_byte_buf(NULL, (uint8_t)text[0]);
     }
     const int len = vim_strsize(text);
     if (maxlen > 0 && retval + len >= maxlen) {
@@ -1917,7 +1917,7 @@ void msg_prt_line(char *s, int list)
         s--;
       } else if (c != NUL && (n = byte2cells(c)) > 1) {
         n_extra = n - 1;
-        p_extra = (char *)transchar_byte_buf(NULL, c);
+        p_extra = transchar_byte_buf(NULL, c);
         c_extra = NUL;
         c_final = NUL;
         c = (unsigned char)(*p_extra++);
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 2edd1772ca..d66ed9abff 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -5162,7 +5162,7 @@ void write_reg_contents_ex(int name, const char *str, ssize_t len, bool must_app
 /// @param str string or list of strings to put in register
 /// @param len length of the string (Ignored when str_list=true.)
 /// @param blocklen width of visual block, or -1 for "I don't know."
-/// @param str_list True if str is `char_u **`.
+/// @param str_list True if str is `char **`.
 static void str_to_reg(yankreg_T *y_ptr, MotionType yank_type, const char *str, size_t len,
                        colnr_T blocklen, bool str_list)
   FUNC_ATTR_NONNULL_ALL
diff --git a/src/nvim/option.c b/src/nvim/option.c
index f672b3ab6f..8fa719c3a9 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -421,7 +421,7 @@ static void set_option_default(const int opt_idx, int opt_flags)
 
   // pointer to variable for current option
   vimoption_T *opt = &options[opt_idx];
-  char_u *varp = (char_u *)get_varp_scope(opt, both ? OPT_LOCAL : opt_flags);
+  char *varp = get_varp_scope(opt, both ? OPT_LOCAL : opt_flags);
   uint32_t flags = opt->flags;
   if (varp != NULL) {       // skip hidden option, nothing to do for it
     if (flags & P_STRING) {
@@ -833,7 +833,7 @@ static void do_set_num(int opt_idx, int opt_flags, char **argp, int nextchar, co
   if (op == OP_REMOVING) {
     value = *(long *)varp - value;
   }
-  *errmsg = set_num_option(opt_idx, (char_u *)varp, (long)value,
+  *errmsg = set_num_option(opt_idx, (char *)varp, (long)value,
                            errbuf, errbuflen, opt_flags);
 }
 
@@ -847,7 +847,7 @@ static void munge_string_opt_val(char **varp, char **oldval, char **const origva
   if (varp == &p_kp && (**argp == NUL || **argp == ' ')) {
     *save_argp = *argp;
     *argp = ":help";
-  } else if (varp == &p_bs && ascii_isdigit(**(char_u **)varp)) {
+  } else if (varp == &p_bs && ascii_isdigit((uint8_t)(**varp))) {
     // Convert 'backspace' number to string, for
     // adding, prepending and removing string.
     const int i = getdigits_int(varp, true, 0);
@@ -927,7 +927,7 @@ static void do_set_string(int opt_idx, int opt_flags, char **argp, int nextchar,
   // reset, use the global value here.
   if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0
       && ((int)options[opt_idx].indir & PV_BOTH)) {
-    varp = (char *)options[opt_idx].var;
+    varp = options[opt_idx].var;
   }
 
   // The old value is kept until we are sure that the new value is valid.
@@ -1439,7 +1439,7 @@ static void do_set_option(int opt_flags, char **argp, bool *did_show, char *errb
       showoneopt(&options[opt_idx], opt_flags);
       if (p_verbose > 0) {
         // Mention where the option was last set.
-        if (varp == (char *)options[opt_idx].var) {
+        if (varp == options[opt_idx].var) {
           option_last_set_msg(options[opt_idx].last_set);
         } else if ((int)options[opt_idx].indir & PV_WIN) {
           option_last_set_msg(curwin->w_p_script_ctx[(int)options[opt_idx].indir & PV_MASK]);
@@ -1735,7 +1735,7 @@ static char *option_expand(int opt_idx, char *val)
   // For 'spellsuggest' expand after "file:".
   expand_env_esc(val, NameBuff, MAXPATHL,
                  (char **)options[opt_idx].var == &p_tags, false,
-                 (char_u **)options[opt_idx].var == (char_u **)&p_sps ? "file:" :
+                 (char **)options[opt_idx].var == &p_sps ? "file:" :
                  NULL);
   if (strcmp(NameBuff, val) == 0) {   // they are the same
     return NULL;
@@ -2274,7 +2274,7 @@ static char *set_bool_option(const int opt_idx, char *const varp, const int valu
 /// @param[in]  opt_flags  OPT_LOCAL, OPT_GLOBAL or OPT_MODELINE.
 ///
 /// @return NULL on success, error message on error.
-static char *set_num_option(int opt_idx, char_u *varp, long value, char *errbuf, size_t errbuflen,
+static char *set_num_option(int opt_idx, char *varp, long value, char *errbuf, size_t errbuflen,
                             int opt_flags)
 {
   char *errmsg = NULL;
@@ -2905,7 +2905,7 @@ getoption_T get_option_value(const char *name, long *numval, char **stringval, u
     return gov_unknown;
   }
 
-  char_u *varp = (char_u *)get_varp_scope(&(options[opt_idx]), scope);
+  char *varp = get_varp_scope(&(options[opt_idx]), scope);
 
   if (flagsp != NULL) {
     // Return the P_xxxx option flags.
@@ -3010,7 +3010,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o
     return rv;
   }
 
-  char_u *varp = NULL;
+  char *varp = NULL;
 
   if (opt_type == SREQ_GLOBAL) {
     if (p->var == VAR_WIN) {
@@ -3030,7 +3030,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o
         // only getting a pointer, no need to use aucmd_prepbuf()
         curbuf = (buf_T *)from;
         curwin->w_buffer = curbuf;
-        varp = (char_u *)get_varp_scope(p, OPT_LOCAL);
+        varp = get_varp_scope(p, OPT_LOCAL);
         curbuf = save_curbuf;
         curwin->w_buffer = curbuf;
       }
@@ -3038,7 +3038,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o
       win_T *save_curwin = curwin;
       curwin = (win_T *)from;
       curbuf = curwin->w_buffer;
-      varp = (char_u *)get_varp_scope(p, OPT_LOCAL);
+      varp = get_varp_scope(p, OPT_LOCAL);
       curwin = save_curwin;
       curbuf = curwin->w_buffer;
     }
@@ -3109,7 +3109,7 @@ char *set_option_value(const char *const name, const long number, const char *co
     return set_string_option(opt_idx, s, opt_flags, errbuf, sizeof(errbuf));
   }
 
-  char_u *varp = (char_u *)get_varp_scope(&(options[opt_idx]), opt_flags);
+  char *varp = get_varp_scope(&(options[opt_idx]), opt_flags);
   if (varp == NULL) {
     // hidden option is not changed
     return NULL;
@@ -3146,7 +3146,7 @@ char *set_option_value(const char *const name, const long number, const char *co
   if (flags & P_NUM) {
     return set_num_option(opt_idx, varp, numval, errbuf, sizeof(errbuf), opt_flags);
   }
-  return set_bool_option(opt_idx, (char *)varp, (int)numval, opt_flags);
+  return set_bool_option(opt_idx, varp, (int)numval, opt_flags);
 }
 
 /// Call set_option_value() and when an error is returned report it.
@@ -3243,7 +3243,7 @@ static void showoptions(bool all, int opt_flags)
           varp = get_varp_scope(p, opt_flags);
         }
       } else {
-        varp = (char *)get_varp(p);
+        varp = get_varp(p);
       }
       if (varp != NULL
           && (all == 1 || (all == 0 && !optval_default(p, varp)))) {
@@ -3349,7 +3349,7 @@ static void showoneopt(vimoption_T *p, int opt_flags)
   silent_mode = false;
   info_message = true;          // use os_msg(), not os_errmsg()
 
-  char_u *varp = (char_u *)get_varp_scope(p, opt_flags);
+  char *varp = get_varp_scope(p, opt_flags);
 
   // for 'modified' we also need to check if 'ff' or 'fenc' changed.
   if ((p->flags & P_BOOL) && ((int *)varp == &curbuf->b_changed
@@ -3427,12 +3427,12 @@ int makeset(FILE *fd, int opt_flags, int local_only)
         }
 
         if ((opt_flags & OPT_SKIPRTP)
-            && (p->var == (char_u *)&p_rtp || p->var == (char_u *)&p_pp)) {
+            && (p->var == (char *)&p_rtp || p->var == (char *)&p_pp)) {
           continue;
         }
 
         int round = 2;
-        char_u *varp_local = NULL;  // fresh value
+        char *varp_local = NULL;  // fresh value
         if (p->indir != PV_NONE) {
           if (p->var == VAR_WIN) {
             // skip window-local option when only doing globals
@@ -3442,11 +3442,11 @@ int makeset(FILE *fd, int opt_flags, int local_only)
             // When fresh value of window-local option is not at the
             // default, need to write it too.
             if (!(opt_flags & OPT_GLOBAL) && !local_only) {
-              char_u *varp_fresh = (char_u *)get_varp_scope(p, OPT_GLOBAL);  // local value
-              if (!optval_default(p, (char *)varp_fresh)) {
+              char *varp_fresh = get_varp_scope(p, OPT_GLOBAL);  // local value
+              if (!optval_default(p, varp_fresh)) {
                 round = 1;
-                varp_local = (char_u *)varp;
-                varp = (char *)varp_fresh;
+                varp_local = varp;
+                varp = varp_fresh;
               }
             }
           }
@@ -3454,7 +3454,7 @@ int makeset(FILE *fd, int opt_flags, int local_only)
 
         // Round 1: fresh value for window-local options.
         // Round 2: other values
-        for (; round <= 2; varp = (char *)varp_local, round++) {
+        for (; round <= 2; varp = varp_local, round++) {
           char *cmd;
           if (round == 1 || (opt_flags & OPT_GLOBAL)) {
             cmd = "set";
@@ -3477,7 +3477,7 @@ int makeset(FILE *fd, int opt_flags, int local_only)
             // already right, avoids reloading the syntax file.
             if (p->indir == PV_SYN || p->indir == PV_FT) {
               if (fprintf(fd, "if &%s != '%s'", p->fullname,
-                          *(char_u **)(varp)) < 0
+                          *(char **)(varp)) < 0
                   || put_eol(fd) < 0) {
                 return FAIL;
               }
@@ -3524,7 +3524,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
   }
 
   char *buf = NULL;
-  char_u *part = NULL;
+  char *part = NULL;
 
   if (*valuep != NULL) {
     if ((flags & P_EXPAND) != 0) {
@@ -3552,8 +3552,8 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_
           if (fprintf(fd, "%s %s+=", cmd, name) < 0) {
             goto fail;
           }
-          (void)copy_option_part(&p, (char *)part, size, ",");
-          if (put_escstr(fd, (char *)part, 2) == FAIL || put_eol(fd) == FAIL) {
+          (void)copy_option_part(&p, part, size, ",");
+          if (put_escstr(fd, part, 2) == FAIL || put_eol(fd) == FAIL) {
             goto fail;
           }
         }
@@ -3586,9 +3586,9 @@ static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep)
     return FAIL;
   }
   long wc;
-  if (wc_use_keyname((char_u *)valuep, &wc)) {
+  if (wc_use_keyname((char *)valuep, &wc)) {
     // print 'wildchar' and 'wildcharm' as a key name
-    if (fputs((char *)get_special_key_name((int)wc, 0), fd) < 0) {
+    if (fputs(get_special_key_name((int)wc, 0), fd) < 0) {
       return FAIL;
     }
   } else if (fprintf(fd, "%" PRId64, (int64_t)(*valuep)) < 0) {
@@ -3727,7 +3727,7 @@ char *get_varp_scope_from(vimoption_T *p, int scope, buf_T *buf, win_T *win)
     if (p->var == VAR_WIN) {
       return GLOBAL_WO(get_varp_from(p, buf, win));
     }
-    return (char *)p->var;
+    return p->var;
   }
   if ((scope & OPT_LOCAL) && ((int)p->indir & PV_BOTH)) {
     switch ((int)p->indir) {
@@ -3790,7 +3790,7 @@ char *get_varp_scope_from(vimoption_T *p, int scope, buf_T *buf, win_T *win)
     }
     return NULL;     // "cannot happen"
   }
-  return (char *)get_varp_from(p, buf, win);
+  return get_varp_from(p, buf, win);
 }
 
 /// Get pointer to option variable, depending on local or global scope.
@@ -3801,7 +3801,7 @@ char *get_varp_scope(vimoption_T *p, int scope)
   return get_varp_scope_from(p, scope, curbuf, curwin);
 }
 
-static char_u *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win)
+static char *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win)
 {
   // hidden option, always return NULL
   if (p->var == NULL) {
@@ -3815,308 +3815,308 @@ static char_u *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win)
   // global option with local value: use local value if it's been set
   case PV_EP:
     return *buf->b_p_ep != NUL
-           ? (char_u *)&buf->b_p_ep : p->var;
+           ? (char *)&buf->b_p_ep : p->var;
   case PV_KP:
     return *buf->b_p_kp != NUL
-           ? (char_u *)&buf->b_p_kp : p->var;
+           ? (char *)&buf->b_p_kp : p->var;
   case PV_PATH:
     return *buf->b_p_path != NUL
-           ? (char_u *)&(buf->b_p_path) : p->var;
+           ? (char *)&(buf->b_p_path) : p->var;
   case PV_AR:
     return buf->b_p_ar >= 0
-           ? (char_u *)&(buf->b_p_ar) : p->var;
+           ? (char *)&(buf->b_p_ar) : p->var;
   case PV_TAGS:
     return *buf->b_p_tags != NUL
-           ? (char_u *)&(buf->b_p_tags) : p->var;
+           ? (char *)&(buf->b_p_tags) : p->var;
   case PV_TC:
     return *buf->b_p_tc != NUL
-           ? (char_u *)&(buf->b_p_tc) : p->var;
+           ? (char *)&(buf->b_p_tc) : p->var;
   case PV_SISO:
     return win->w_p_siso >= 0
-           ? (char_u *)&(win->w_p_siso) : p->var;
+           ? (char *)&(win->w_p_siso) : p->var;
   case PV_SO:
     return win->w_p_so >= 0
-           ? (char_u *)&(win->w_p_so) : p->var;
+           ? (char *)&(win->w_p_so) : p->var;
   case PV_BKC:
     return *buf->b_p_bkc != NUL
-           ? (char_u *)&(buf->b_p_bkc) : p->var;
+           ? (char *)&(buf->b_p_bkc) : p->var;
   case PV_DEF:
     return *buf->b_p_def != NUL
-           ? (char_u *)&(buf->b_p_def) : p->var;
+           ? (char *)&(buf->b_p_def) : p->var;
   case PV_INC:
     return *buf->b_p_inc != NUL
-           ? (char_u *)&(buf->b_p_inc) : p->var;
+           ? (char *)&(buf->b_p_inc) : p->var;
   case PV_DICT:
     return *buf->b_p_dict != NUL
-           ? (char_u *)&(buf->b_p_dict) : p->var;
+           ? (char *)&(buf->b_p_dict) : p->var;
   case PV_TSR:
     return *buf->b_p_tsr != NUL
-           ? (char_u *)&(buf->b_p_tsr) : p->var;
+           ? (char *)&(buf->b_p_tsr) : p->var;
   case PV_TSRFU:
     return *buf->b_p_tsrfu != NUL
-           ? (char_u *)&(buf->b_p_tsrfu) : p->var;
+           ? (char *)&(buf->b_p_tsrfu) : p->var;
   case PV_FP:
     return *buf->b_p_fp != NUL
-           ? (char_u *)&(buf->b_p_fp) : p->var;
+           ? (char *)&(buf->b_p_fp) : p->var;
   case PV_EFM:
     return *buf->b_p_efm != NUL
-           ? (char_u *)&(buf->b_p_efm) : p->var;
+           ? (char *)&(buf->b_p_efm) : p->var;
   case PV_GP:
     return *buf->b_p_gp != NUL
-           ? (char_u *)&(buf->b_p_gp) : p->var;
+           ? (char *)&(buf->b_p_gp) : p->var;
   case PV_MP:
     return *buf->b_p_mp != NUL
-           ? (char_u *)&(buf->b_p_mp) : p->var;
+           ? (char *)&(buf->b_p_mp) : p->var;
   case PV_SBR:
     return *win->w_p_sbr != NUL
-           ? (char_u *)&(win->w_p_sbr) : p->var;
+           ? (char *)&(win->w_p_sbr) : p->var;
   case PV_STL:
     return *win->w_p_stl != NUL
-           ? (char_u *)&(win->w_p_stl) : p->var;
+           ? (char *)&(win->w_p_stl) : p->var;
   case PV_WBR:
     return *win->w_p_wbr != NUL
-           ? (char_u *)&(win->w_p_wbr) : p->var;
+           ? (char *)&(win->w_p_wbr) : p->var;
   case PV_UL:
     return buf->b_p_ul != NO_LOCAL_UNDOLEVEL
-           ? (char_u *)&(buf->b_p_ul) : p->var;
+           ? (char *)&(buf->b_p_ul) : p->var;
   case PV_LW:
     return *buf->b_p_lw != NUL
-           ? (char_u *)&(buf->b_p_lw) : p->var;
+           ? (char *)&(buf->b_p_lw) : p->var;
   case PV_MENC:
     return *buf->b_p_menc != NUL
-           ? (char_u *)&(buf->b_p_menc) : p->var;
+           ? (char *)&(buf->b_p_menc) : p->var;
   case PV_FCS:
     return *win->w_p_fcs != NUL
-           ? (char_u *)&(win->w_p_fcs) : p->var;
+           ? (char *)&(win->w_p_fcs) : p->var;
   case PV_LCS:
     return *win->w_p_lcs != NUL
-           ? (char_u *)&(win->w_p_lcs) : p->var;
+           ? (char *)&(win->w_p_lcs) : p->var;
   case PV_VE:
     return *win->w_p_ve != NUL
-           ? (char_u *)&win->w_p_ve : p->var;
+           ? (char *)&win->w_p_ve : p->var;
 
   case PV_ARAB:
-    return (char_u *)&(win->w_p_arab);
+    return (char *)&(win->w_p_arab);
   case PV_LIST:
-    return (char_u *)&(win->w_p_list);
+    return (char *)&(win->w_p_list);
   case PV_SPELL:
-    return (char_u *)&(win->w_p_spell);
+    return (char *)&(win->w_p_spell);
   case PV_CUC:
-    return (char_u *)&(win->w_p_cuc);
+    return (char *)&(win->w_p_cuc);
   case PV_CUL:
-    return (char_u *)&(win->w_p_cul);
+    return (char *)&(win->w_p_cul);
   case PV_CULOPT:
-    return (char_u *)&(win->w_p_culopt);
+    return (char *)&(win->w_p_culopt);
   case PV_CC:
-    return (char_u *)&(win->w_p_cc);
+    return (char *)&(win->w_p_cc);
   case PV_DIFF:
-    return (char_u *)&(win->w_p_diff);
+    return (char *)&(win->w_p_diff);
   case PV_FDC:
-    return (char_u *)&(win->w_p_fdc);
+    return (char *)&(win->w_p_fdc);
   case PV_FEN:
-    return (char_u *)&(win->w_p_fen);
+    return (char *)&(win->w_p_fen);
   case PV_FDI:
-    return (char_u *)&(win->w_p_fdi);
+    return (char *)&(win->w_p_fdi);
   case PV_FDL:
-    return (char_u *)&(win->w_p_fdl);
+    return (char *)&(win->w_p_fdl);
   case PV_FDM:
-    return (char_u *)&(win->w_p_fdm);
+    return (char *)&(win->w_p_fdm);
   case PV_FML:
-    return (char_u *)&(win->w_p_fml);
+    return (char *)&(win->w_p_fml);
   case PV_FDN:
-    return (char_u *)&(win->w_p_fdn);
+    return (char *)&(win->w_p_fdn);
   case PV_FDE:
-    return (char_u *)&(win->w_p_fde);
+    return (char *)&(win->w_p_fde);
   case PV_FDT:
-    return (char_u *)&(win->w_p_fdt);
+    return (char *)&(win->w_p_fdt);
   case PV_FMR:
-    return (char_u *)&(win->w_p_fmr);
+    return (char *)&(win->w_p_fmr);
   case PV_NU:
-    return (char_u *)&(win->w_p_nu);
+    return (char *)&(win->w_p_nu);
   case PV_RNU:
-    return (char_u *)&(win->w_p_rnu);
+    return (char *)&(win->w_p_rnu);
   case PV_NUW:
-    return (char_u *)&(win->w_p_nuw);
+    return (char *)&(win->w_p_nuw);
   case PV_WFH:
-    return (char_u *)&(win->w_p_wfh);
+    return (char *)&(win->w_p_wfh);
   case PV_WFW:
-    return (char_u *)&(win->w_p_wfw);
+    return (char *)&(win->w_p_wfw);
   case PV_PVW:
-    return (char_u *)&(win->w_p_pvw);
+    return (char *)&(win->w_p_pvw);
   case PV_RL:
-    return (char_u *)&(win->w_p_rl);
+    return (char *)&(win->w_p_rl);
   case PV_RLC:
-    return (char_u *)&(win->w_p_rlc);
+    return (char *)&(win->w_p_rlc);
   case PV_SCROLL:
-    return (char_u *)&(win->w_p_scr);
+    return (char *)&(win->w_p_scr);
   case PV_WRAP:
-    return (char_u *)&(win->w_p_wrap);
+    return (char *)&(win->w_p_wrap);
   case PV_LBR:
-    return (char_u *)&(win->w_p_lbr);
+    return (char *)&(win->w_p_lbr);
   case PV_BRI:
-    return (char_u *)&(win->w_p_bri);
+    return (char *)&(win->w_p_bri);
   case PV_BRIOPT:
-    return (char_u *)&(win->w_p_briopt);
+    return (char *)&(win->w_p_briopt);
   case PV_SCBIND:
-    return (char_u *)&(win->w_p_scb);
+    return (char *)&(win->w_p_scb);
   case PV_CRBIND:
-    return (char_u *)&(win->w_p_crb);
+    return (char *)&(win->w_p_crb);
   case PV_COCU:
-    return (char_u *)&(win->w_p_cocu);
+    return (char *)&(win->w_p_cocu);
   case PV_COLE:
-    return (char_u *)&(win->w_p_cole);
+    return (char *)&(win->w_p_cole);
 
   case PV_AI:
-    return (char_u *)&(buf->b_p_ai);
+    return (char *)&(buf->b_p_ai);
   case PV_BIN:
-    return (char_u *)&(buf->b_p_bin);
+    return (char *)&(buf->b_p_bin);
   case PV_BOMB:
-    return (char_u *)&(buf->b_p_bomb);
+    return (char *)&(buf->b_p_bomb);
   case PV_BH:
-    return (char_u *)&(buf->b_p_bh);
+    return (char *)&(buf->b_p_bh);
   case PV_BT:
-    return (char_u *)&(buf->b_p_bt);
+    return (char *)&(buf->b_p_bt);
   case PV_BL:
-    return (char_u *)&(buf->b_p_bl);
+    return (char *)&(buf->b_p_bl);
   case PV_CHANNEL:
-    return (char_u *)&(buf->b_p_channel);
+    return (char *)&(buf->b_p_channel);
   case PV_CI:
-    return (char_u *)&(buf->b_p_ci);
+    return (char *)&(buf->b_p_ci);
   case PV_CIN:
-    return (char_u *)&(buf->b_p_cin);
+    return (char *)&(buf->b_p_cin);
   case PV_CINK:
-    return (char_u *)&(buf->b_p_cink);
+    return (char *)&(buf->b_p_cink);
   case PV_CINO:
-    return (char_u *)&(buf->b_p_cino);
+    return (char *)&(buf->b_p_cino);
   case PV_CINSD:
-    return (char_u *)&(buf->b_p_cinsd);
+    return (char *)&(buf->b_p_cinsd);
   case PV_CINW:
-    return (char_u *)&(buf->b_p_cinw);
+    return (char *)&(buf->b_p_cinw);
   case PV_COM:
-    return (char_u *)&(buf->b_p_com);
+    return (char *)&(buf->b_p_com);
   case PV_CMS:
-    return (char_u *)&(buf->b_p_cms);
+    return (char *)&(buf->b_p_cms);
   case PV_CPT:
-    return (char_u *)&(buf->b_p_cpt);
+    return (char *)&(buf->b_p_cpt);
 #ifdef BACKSLASH_IN_FILENAME
   case PV_CSL:
-    return (char_u *)&(buf->b_p_csl);
+    return (char *)&(buf->b_p_csl);
 #endif
   case PV_CFU:
-    return (char_u *)&(buf->b_p_cfu);
+    return (char *)&(buf->b_p_cfu);
   case PV_OFU:
-    return (char_u *)&(buf->b_p_ofu);
+    return (char *)&(buf->b_p_ofu);
   case PV_EOF:
-    return (char_u *)&(buf->b_p_eof);
+    return (char *)&(buf->b_p_eof);
   case PV_EOL:
-    return (char_u *)&(buf->b_p_eol);
+    return (char *)&(buf->b_p_eol);
   case PV_FIXEOL:
-    return (char_u *)&(buf->b_p_fixeol);
+    return (char *)&(buf->b_p_fixeol);
   case PV_ET:
-    return (char_u *)&(buf->b_p_et);
+    return (char *)&(buf->b_p_et);
   case PV_FENC:
-    return (char_u *)&(buf->b_p_fenc);
+    return (char *)&(buf->b_p_fenc);
   case PV_FF:
-    return (char_u *)&(buf->b_p_ff);
+    return (char *)&(buf->b_p_ff);
   case PV_FT:
-    return (char_u *)&(buf->b_p_ft);
+    return (char *)&(buf->b_p_ft);
   case PV_FO:
-    return (char_u *)&(buf->b_p_fo);
+    return (char *)&(buf->b_p_fo);
   case PV_FLP:
-    return (char_u *)&(buf->b_p_flp);
+    return (char *)&(buf->b_p_flp);
   case PV_IMI:
-    return (char_u *)&(buf->b_p_iminsert);
+    return (char *)&(buf->b_p_iminsert);
   case PV_IMS:
-    return (char_u *)&(buf->b_p_imsearch);
+    return (char *)&(buf->b_p_imsearch);
   case PV_INF:
-    return (char_u *)&(buf->b_p_inf);
+    return (char *)&(buf->b_p_inf);
   case PV_ISK:
-    return (char_u *)&(buf->b_p_isk);
+    return (char *)&(buf->b_p_isk);
   case PV_INEX:
-    return (char_u *)&(buf->b_p_inex);
+    return (char *)&(buf->b_p_inex);
   case PV_INDE:
-    return (char_u *)&(buf->b_p_inde);
+    return (char *)&(buf->b_p_inde);
   case PV_INDK:
-    return (char_u *)&(buf->b_p_indk);
+    return (char *)&(buf->b_p_indk);
   case PV_FEX:
-    return (char_u *)&(buf->b_p_fex);
+    return (char *)&(buf->b_p_fex);
   case PV_LISP:
-    return (char_u *)&(buf->b_p_lisp);
+    return (char *)&(buf->b_p_lisp);
   case PV_LOP:
-    return (char_u *)&(buf->b_p_lop);
+    return (char *)&(buf->b_p_lop);
   case PV_ML:
-    return (char_u *)&(buf->b_p_ml);
+    return (char *)&(buf->b_p_ml);
   case PV_MPS:
-    return (char_u *)&(buf->b_p_mps);
+    return (char *)&(buf->b_p_mps);
   case PV_MA:
-    return (char_u *)&(buf->b_p_ma);
+    return (char *)&(buf->b_p_ma);
   case PV_MOD:
-    return (char_u *)&(buf->b_changed);
+    return (char *)&(buf->b_changed);
   case PV_NF:
-    return (char_u *)&(buf->b_p_nf);
+    return (char *)&(buf->b_p_nf);
   case PV_PI:
-    return (char_u *)&(buf->b_p_pi);
+    return (char *)&(buf->b_p_pi);
   case PV_QE:
-    return (char_u *)&(buf->b_p_qe);
+    return (char *)&(buf->b_p_qe);
   case PV_RO:
-    return (char_u *)&(buf->b_p_ro);
+    return (char *)&(buf->b_p_ro);
   case PV_SCBK:
-    return (char_u *)&(buf->b_p_scbk);
+    return (char *)&(buf->b_p_scbk);
   case PV_SI:
-    return (char_u *)&(buf->b_p_si);
+    return (char *)&(buf->b_p_si);
   case PV_STS:
-    return (char_u *)&(buf->b_p_sts);
+    return (char *)&(buf->b_p_sts);
   case PV_SUA:
-    return (char_u *)&(buf->b_p_sua);
+    return (char *)&(buf->b_p_sua);
   case PV_SWF:
-    return (char_u *)&(buf->b_p_swf);
+    return (char *)&(buf->b_p_swf);
   case PV_SMC:
-    return (char_u *)&(buf->b_p_smc);
+    return (char *)&(buf->b_p_smc);
   case PV_SYN:
-    return (char_u *)&(buf->b_p_syn);
+    return (char *)&(buf->b_p_syn);
   case PV_SPC:
-    return (char_u *)&(win->w_s->b_p_spc);
+    return (char *)&(win->w_s->b_p_spc);
   case PV_SPF:
-    return (char_u *)&(win->w_s->b_p_spf);
+    return (char *)&(win->w_s->b_p_spf);
   case PV_SPL:
-    return (char_u *)&(win->w_s->b_p_spl);
+    return (char *)&(win->w_s->b_p_spl);
   case PV_SPO:
-    return (char_u *)&(win->w_s->b_p_spo);
+    return (char *)&(win->w_s->b_p_spo);
   case PV_SW:
-    return (char_u *)&(buf->b_p_sw);
+    return (char *)&(buf->b_p_sw);
   case PV_TFU:
-    return (char_u *)&(buf->b_p_tfu);
+    return (char *)&(buf->b_p_tfu);
   case PV_TS:
-    return (char_u *)&(buf->b_p_ts);
+    return (char *)&(buf->b_p_ts);
   case PV_TW:
-    return (char_u *)&(buf->b_p_tw);
+    return (char *)&(buf->b_p_tw);
   case PV_UDF:
-    return (char_u *)&(buf->b_p_udf);
+    return (char *)&(buf->b_p_udf);
   case PV_WM:
-    return (char_u *)&(buf->b_p_wm);
+    return (char *)&(buf->b_p_wm);
   case PV_VSTS:
-    return (char_u *)&(buf->b_p_vsts);
+    return (char *)&(buf->b_p_vsts);
   case PV_VTS:
-    return (char_u *)&(buf->b_p_vts);
+    return (char *)&(buf->b_p_vts);
   case PV_KMAP:
-    return (char_u *)&(buf->b_p_keymap);
+    return (char *)&(buf->b_p_keymap);
   case PV_SCL:
-    return (char_u *)&(win->w_p_scl);
+    return (char *)&(win->w_p_scl);
   case PV_WINHL:
-    return (char_u *)&(win->w_p_winhl);
+    return (char *)&(win->w_p_winhl);
   case PV_WINBL:
-    return (char_u *)&(win->w_p_winbl);
+    return (char *)&(win->w_p_winbl);
   case PV_STC:
-    return (char_u *)&(win->w_p_stc);
+    return (char *)&(win->w_p_stc);
   default:
     iemsg(_("E356: get_varp ERROR"));
   }
   // always return a valid pointer to avoid a crash!
-  return (char_u *)&(buf->b_p_wm);
+  return (char *)&(buf->b_p_wm);
 }
 
 /// Get pointer to option variable.
-static inline char_u *get_varp(vimoption_T *p)
+static inline char *get_varp(vimoption_T *p)
 {
   return get_varp_from(p, curbuf, curwin);
 }
@@ -4608,7 +4608,7 @@ void set_imsearch_global(buf_T *buf)
 }
 
 static int expand_option_idx = -1;
-static char_u expand_option_name[5] = { 't', '_', NUL, NUL, NUL };
+static char expand_option_name[5] = { 't', '_', NUL, NUL, NUL };
 static int expand_option_flags = 0;
 
 /// @param opt_flags  OPT_GLOBAL and/or OPT_LOCAL
@@ -4670,8 +4670,8 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags)
     }
     nextchar = *++p;
     is_term_option = true;
-    expand_option_name[2] = (char_u)KEY2TERMCAP0(key);
-    expand_option_name[3] = KEY2TERMCAP1(key);
+    expand_option_name[2] = (char)(uint8_t)KEY2TERMCAP0(key);
+    expand_option_name[3] = (char)(uint8_t)KEY2TERMCAP1(key);
   } else {
     if (p[0] == 't' && p[1] == '_') {
       p += 2;
@@ -4683,8 +4683,8 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags)
       }
       nextchar = *++p;
       is_term_option = true;
-      expand_option_name[2] = (char_u)p[-2];
-      expand_option_name[3] = (char_u)p[-1];
+      expand_option_name[2] = p[-2];
+      expand_option_name[3] = p[-1];
     } else {
       // Allow * wildcard.
       while (ASCII_ISALNUM(*p) || *p == '_' || *p == '*') {
@@ -4734,7 +4734,7 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags)
   xp->xp_pattern = p + 1;
 
   if (flags & P_EXPAND) {
-    p = (char *)options[opt_idx].var;
+    p = options[opt_idx].var;
     if (p == (char *)&p_bdir
         || p == (char *)&p_dir
         || p == (char *)&p_path
@@ -4778,7 +4778,7 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags)
     }
 
     // for 'spellsuggest' start at "file:"
-    if (options[opt_idx].var == (char_u *)&p_sps
+    if (options[opt_idx].var == (char *)&p_sps
         && strncmp(p, "file:", 5) == 0) {
       xp->xp_pattern = p + 5;
       break;
@@ -4915,7 +4915,7 @@ void ExpandOldSetting(int *numMatches, char ***matches)
 
   // For a terminal key code expand_option_idx is < 0.
   if (expand_option_idx < 0) {
-    expand_option_idx = findoption((const char *)expand_option_name);
+    expand_option_idx = findoption(expand_option_name);
   }
 
   if (expand_option_idx >= 0) {
@@ -4959,8 +4959,8 @@ static void option_value2string(vimoption_T *opp, int scope)
   if (opp->flags & P_NUM) {
     long wc = 0;
 
-    if (wc_use_keyname((char_u *)varp, &wc)) {
-      xstrlcpy(NameBuff, (char *)get_special_key_name((int)wc, 0), sizeof(NameBuff));
+    if (wc_use_keyname(varp, &wc)) {
+      xstrlcpy(NameBuff, get_special_key_name((int)wc, 0), sizeof(NameBuff));
     } else if (wc != 0) {
       xstrlcpy(NameBuff, transchar((int)wc), sizeof(NameBuff));
     } else {
@@ -4984,7 +4984,7 @@ static void option_value2string(vimoption_T *opp, int scope)
 /// Return true if "varp" points to 'wildchar' or 'wildcharm' and it can be
 /// printed as a keyname.
 /// "*wcp" is set to the value of the option if it's 'wildchar' or 'wildcharm'.
-static int wc_use_keyname(const char_u *varp, long *wcp)
+static int wc_use_keyname(const char *varp, long *wcp)
 {
   if (((long *)varp == &p_wc) || ((long *)varp == &p_wcm)) {
     *wcp = *(long *)varp;
@@ -5198,7 +5198,7 @@ void fill_breakat_flags(void)
 int fill_culopt_flags(char *val, win_T *wp)
 {
   char *p;
-  char_u culopt_flags_new = 0;
+  uint8_t culopt_flags_new = 0;
 
   if (val == NULL) {
     p = wp->w_p_culopt;
@@ -5568,7 +5568,7 @@ dict_T *get_winbuf_options(const int bufopt)
 
     if ((bufopt && (opt->indir & PV_BUF))
         || (!bufopt && (opt->indir & PV_WIN))) {
-      char_u *varp = get_varp(opt);
+      char *varp = get_varp(opt);
 
       if (varp != NULL) {
         if (opt->flags & P_STRING) {
@@ -5673,7 +5673,7 @@ static Dictionary vimoption2dict(vimoption_T *opt, int req_scope, buf_T *buf, wi
   const char *type;
   Object def;
   // TODO(bfredl): do you even nocp?
-  char_u *def_val = (char_u *)opt->def_val;
+  char *def_val = opt->def_val;
   if (opt->flags & P_STRING) {
     type = "string";
     def = CSTR_TO_OBJ(def_val ? (char *)def_val : "");
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index de289fe54e..b7ea8cd2c2 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -993,7 +993,7 @@ typedef struct vimoption {
   char *fullname;        // full option name
   char *shortname;       // permissible abbreviation
   uint32_t flags;               // see below
-  char_u *var;             // global option: pointer to variable;
+  char *var;               // global option: pointer to variable;
                            // window-local option: VAR_WIN;
                            // buffer-local option: global value
   idopt_T indir;                // global option: PV_NONE;
@@ -1018,6 +1018,6 @@ typedef struct vimoption {
 
 // Options local to a window have a value local to a buffer and global to all
 // buffers.  Indicate this by setting "var" to VAR_WIN.
-#define VAR_WIN ((char_u *)-1)
+#define VAR_WIN ((char *)-1)
 
 #endif  // NVIM_OPTION_DEFS_H
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index c65f822080..9108059b4d 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -150,7 +150,7 @@ typedef struct matchinf_S {
 
   // for when checking a compound word
   int mi_compoff;                       // start of following word offset
-  char_u mi_compflags[MAXWLEN];         // flags for compound words used
+  uint8_t mi_compflags[MAXWLEN];        // flags for compound words used
   int mi_complen;                       // nr of compound words used
   int mi_compextra;                     // nr of COMPOUNDROOT words
 
@@ -961,7 +961,7 @@ bool can_compound(slang_T *slang, const char *word, const uint8_t *flags)
 // compound rule.  This is used to stop trying a compound if the flags
 // collected so far can't possibly match any compound rule.
 // Caller must check that slang->sl_comprules is not NULL.
-bool match_compoundrule(slang_T *slang, const char_u *compflags)
+bool match_compoundrule(slang_T *slang, const uint8_t *compflags)
 {
   // loop over all the COMPOUNDRULE entries
   for (char *p = (char *)slang->sl_comprules; *p != NUL; p++) {
@@ -1748,7 +1748,7 @@ void count_common_word(slang_T *lp, char *word, int len, uint8_t count)
     wc = xmalloc(offsetof(wordcount_T, wc_word) + p_len + 1);
     memcpy(wc->wc_word, p, p_len + 1);
     wc->wc_count = count;
-    hash_add_item(&lp->sl_wordcount, hi, (char *)wc->wc_word, hash);
+    hash_add_item(&lp->sl_wordcount, hi, wc->wc_word, hash);
   } else {
     wc = HI2WC(hi);
     wc->wc_count = (uint16_t)(wc->wc_count + count);
diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h
index 1c163071c5..0b95cfed8e 100644
--- a/src/nvim/spell_defs.h
+++ b/src/nvim/spell_defs.h
@@ -243,7 +243,7 @@ typedef enum {
 
 typedef struct wordcount_S {
   uint16_t wc_count;                ///< nr of times word was seen
-  char_u wc_word[];                 ///< word
+  char wc_word[];                   ///< word
 } wordcount_T;
 
 #define WC_KEY_OFF   offsetof(wordcount_T, wc_word)
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index c68eee3526..aa76dcbd32 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -404,14 +404,14 @@ typedef struct sblock_S sblock_T;
 struct sblock_S {
   int sb_used;                  // nr of bytes already in use
   sblock_T *sb_next;         // next block in list
-  char_u sb_data[];            // data
+  char sb_data[];            // data
 };
 
 // A node in the tree.
 typedef struct wordnode_S wordnode_T;
 struct wordnode_S {
   union {   // shared to save space
-    char_u hashkey[6];          // the hash key, only used while compressing
+    uint8_t hashkey[6];         // the hash key, only used while compressing
     int index;                  // index in written nodes (valid after first
                                 // round)
   } wn_u1;
@@ -422,17 +422,17 @@ struct wordnode_S {
   wordnode_T *wn_child;        // child (next byte in word)
   wordnode_T *wn_sibling;      // next sibling (alternate byte in word,
                                //   always sorted)
-  int wn_refs;                  // Nr. of references to this node.  Only
-                                //   relevant for first node in a list of
-                                //   siblings, in following siblings it is
-                                //   always one.
-  char_u wn_byte;               // Byte for this node. NUL for word end
+  int wn_refs;                 // Nr. of references to this node.  Only
+                               //   relevant for first node in a list of
+                               //   siblings, in following siblings it is
+                               //   always one.
+  uint8_t wn_byte;             // Byte for this node. NUL for word end
 
   // Info for when "wn_byte" is NUL.
   // In PREFIXTREE "wn_region" is used for the prefcondnr.
   // In the soundfolded word tree "wn_flags" has the MSW of the wordnr and
   // "wn_region" the LSW of the wordnr.
-  char_u wn_affixID;            // supported/required prefix ID or 0
+  uint8_t wn_affixID;           // supported/required prefix ID or 0
   uint16_t wn_flags;            // WF_ flags
   int16_t wn_region;            // region mask
 
@@ -482,7 +482,7 @@ typedef struct spellinfo_S {
   char *si_info;                // info text chars or NULL
   int si_region_count;          // number of regions supported (1 when there
                                 // are no regions)
-  char_u si_region_name[MAXREGIONS * 2 + 1];
+  char si_region_name[MAXREGIONS * 2 + 1];
   // region names; used only if
   // si_region_count > 1)
 
@@ -508,7 +508,7 @@ typedef struct spellinfo_S {
   garray_T si_comppat;          // CHECKCOMPOUNDPATTERN items, each stored as
                                 // a string
   char *si_compflags;           // flags used for compounding
-  char_u si_nobreak;            // NOBREAK
+  char si_nobreak;              // NOBREAK
   char *si_syllable;            // syllable string
   garray_T si_prefcond;         // table with conditions for postponed
                                 // prefixes, each stored as a string
@@ -985,7 +985,7 @@ someerror:
           if (c < 0) {
             goto someerror;
           }
-          GA_APPEND(char_u, &ga, (char_u)c);
+          GA_APPEND(uint8_t, &ga, (uint8_t)c);
           if (c == NUL) {
             break;
           }
@@ -1060,7 +1060,7 @@ static int read_region_section(FILE *fd, slang_T *lp, int len)
 static int read_charflags_section(FILE *fd)
 {
   char *flags;
-  char_u *fol;
+  char *fol;
   int flagslen, follen;
 
   // <charflagslen> <charflags>
@@ -1070,7 +1070,7 @@ static int read_charflags_section(FILE *fd)
   }
 
   // <folcharslen> <folchars>
-  fol = (char_u *)read_cnt_string(fd, 2, &follen);
+  fol = read_cnt_string(fd, 2, &follen);
   if (follen < 0) {
     xfree(flags);
     return follen;
@@ -1078,7 +1078,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(flags, flagslen, (char *)fol);
+    set_spell_charflags(flags, flagslen, fol);
   }
 
   xfree(flags);
@@ -2538,9 +2538,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
               if (idx < 0) {
                 // Not found, add a new condition.
                 idx = spin->si_prefcond.ga_len;
-                char_u **pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
+                char **pp = GA_APPEND_VIA_PTR(char *, &spin->si_prefcond);
                 *pp = (aff_entry->ae_cond == NULL) ?
-                      NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond);
+                      NULL : getroom_save(spin, aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
@@ -2565,7 +2565,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
               if (aff_entry->ae_compforbid) {
                 n |= WFP_COMPFORBID;
               }
-              tree_add_word(spin, (char_u *)p, spin->si_prefroot, n,
+              tree_add_word(spin, p, spin->si_prefroot, n,
                             idx, cur_aff->ah_newID);
               did_postpone_prefix = true;
             }
@@ -3232,7 +3232,7 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
       if (spin->si_compflags != NULL) {
         // Need to store the list of compound flags with the word.
         // Concatenate them to the list of prefix IDs.
-        get_compflags(affile, afflist, (char_u *)store_afflist + pfxlen);
+        get_compflags(affile, afflist, store_afflist + pfxlen);
       }
     }
 
@@ -3349,7 +3349,7 @@ static int get_pfxlist(afffile_T *affile, char *afflist, char *store_afflist)
 // Get the list of compound IDs from the affix list "afflist" that are used
 // for compound words.
 // Puts the flags in "store_afflist[]".
-static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflist)
+static void get_compflags(afffile_T *affile, char *afflist, char *store_afflist)
 {
   int cnt = 0;
   char key[AH_KEY_LEN];
@@ -3362,7 +3362,7 @@ static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflis
       xstrlcpy(key, prevp, (size_t)(p - prevp) + 1);
       hi = hash_find(&affile->af_comp, (char *)key);
       if (!HASHITEM_EMPTY(hi)) {
-        store_afflist[cnt++] = (char_u)HI2CI(hi)->ci_newID;
+        store_afflist[cnt++] = (char)(uint8_t)HI2CI(hi)->ci_newID;
       }
     }
     if (affile->af_flagtype == AFT_NUM && *p == ',') {
@@ -3530,7 +3530,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
                 if (spin->si_compflags != NULL) {
                   // Get compound IDS from the affix list.
                   get_compflags(affile, ae->ae_flags,
-                                (char_u *)use_pfxlist + use_pfxlen);
+                                use_pfxlist + use_pfxlen);
                 } else {
                   use_pfxlist[use_pfxlen] = NUL;
                 }
@@ -3835,7 +3835,7 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
     spin->si_blocks_cnt++;
   }
 
-  p = (char *)bl->sb_data + bl->sb_used;
+  p = bl->sb_data + bl->sb_used;
   bl->sb_used += (int)len;
 
   return p;
@@ -3913,7 +3913,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
   (void)spell_casefold(curwin, word, len, foldword, MAXWLEN);
   for (const char *p = pfxlist; res == OK; p++) {
     if (!need_affix || (p != NULL && *p != NUL)) {
-      res = tree_add_word(spin, (char_u *)foldword, spin->si_foldroot, ct | flags,
+      res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
                           region, p == NULL ? 0 : *p);
     }
     if (p == NULL || *p == NUL) {
@@ -3925,7 +3925,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
   if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
     for (const char *p = pfxlist; res == OK; p++) {
       if (!need_affix || (p != NULL && *p != NUL)) {
-        res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags,
+        res = tree_add_word(spin, word, spin->si_keeproot, flags,
                             region, p == NULL ? 0 : *p);
       }
       if (p == NULL || *p == NUL) {
@@ -3941,7 +3941,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
 // When "flags" < 0 we are adding to the prefix tree where "flags" is used for
 // "rare" and "region" is the condition nr.
 // Returns FAIL when out of memory.
-static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root, int flags,
+static int tree_add_word(spellinfo_T *spin, const char *word, wordnode_T *root, int flags,
                          int region, int affixID)
 {
   wordnode_T *node = root;
@@ -3993,7 +3993,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
     // higher byte value.  For zero bytes (end of word) the sorting is
     // done on flags and then on affixID.
     while (node != NULL
-           && (node->wn_byte < word[i]
+           && (node->wn_byte < (uint8_t)word[i]
                || (node->wn_byte == NUL
                    && (flags < 0
                        ? node->wn_affixID < (unsigned)affixID
@@ -4007,7 +4007,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
       node = *prev;
     }
     if (node == NULL
-        || node->wn_byte != word[i]
+        || node->wn_byte != (uint8_t)word[i]
         || (word[i] == NUL
             && (flags < 0
                 || spin->si_sugtree
@@ -4018,7 +4018,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
       if (np == NULL) {
         return FAIL;
       }
-      np->wn_byte = word[i];
+      np->wn_byte = (uint8_t)word[i];
 
       // If "node" is NULL this is a new child or the end of the sibling
       // list: ref count is one.  Otherwise use ref count of sibling and
@@ -4040,7 +4040,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
     if (word[i] == NUL) {
       node->wn_flags = (uint16_t)flags;
       node->wn_region |= (int16_t)region;
-      node->wn_affixID = (char_u)affixID;
+      node->wn_affixID = (uint8_t)affixID;
       break;
     }
     prev = &node->wn_child;
@@ -4266,7 +4266,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
   // Make a hash key for the node and its siblings, so that we can quickly
   // find a lookalike node.  This must be done after compressing the sibling
   // list, otherwise the hash key would become invalid by the compression.
-  node->wn_u1.hashkey[0] = (char_u)len;
+  node->wn_u1.hashkey[0] = (uint8_t)len;
   nr = 0;
   for (np = node; np != NULL; np = np->wn_sibling) {
     if (np->wn_byte == NUL) {
@@ -4281,13 +4281,13 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
 
   // Avoid NUL bytes, it terminates the hash key.
   n = nr & 0xff;
-  node->wn_u1.hashkey[1] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[1] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 8) & 0xff;
-  node->wn_u1.hashkey[2] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[2] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 16) & 0xff;
-  node->wn_u1.hashkey[3] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[3] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 24) & 0xff;
-  node->wn_u1.hashkey[4] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[4] = n == 0 ? 1 : (uint8_t)n;
   node->wn_u1.hashkey[5] = NUL;
 
   // Check for CTRL-C pressed now and then.
@@ -4957,8 +4957,8 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
   int depth;
   idx_T arridx[MAXWLEN];
   int curi[MAXWLEN];
-  char_u tword[MAXWLEN];
-  char_u tsalword[MAXWLEN];
+  char tword[MAXWLEN];
+  char tsalword[MAXWLEN];
   int c;
   idx_T n;
   unsigned words_done = 0;
@@ -4999,7 +4999,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
       if (c == 0) {
         // Sound-fold the word.
         tword[depth] = NUL;
-        spell_soundfold(slang, (char *)tword, true, (char *)tsalword);
+        spell_soundfold(slang, tword, true, tsalword);
 
         // We use the "flags" field for the MSB of the wordnr,
         // "region" for the LSB of the wordnr.
@@ -5024,7 +5024,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
         }
       } else {
         // Normal char, go one level deeper.
-        tword[depth++] = (char_u)c;
+        tword[depth++] = (char)(uint8_t)c;
         arridx[depth] = idxs[n];
         curi[depth] = 1;
         wordcount[depth] = 0;
@@ -5090,12 +5090,11 @@ static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, g
         // following bytes.
         nr -= prev_nr;
         prev_nr += nr;
-        gap->ga_len += offset2bytes(nr,
-                                    (char_u *)gap->ga_data + gap->ga_len);
+        gap->ga_len += offset2bytes(nr, (char *)gap->ga_data + gap->ga_len);
       }
 
       // add the NUL byte
-      ((char_u *)gap->ga_data)[gap->ga_len++] = NUL;
+      ((char *)gap->ga_data)[gap->ga_len++] = NUL;
 
       if (ml_append_buf(spin->si_spellbuf, (linenr_T)wordnr,
                         gap->ga_data, gap->ga_len, true) == FAIL) {
@@ -5126,8 +5125,9 @@ static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, g
 // Convert an offset into a minimal number of bytes.
 // Similar to utf_char2byters, but use 8 bits in followup bytes and avoid NUL
 // bytes.
-static int offset2bytes(int nr, char_u *buf)
+static int offset2bytes(int nr, char *buf_in)
 {
+  uint8_t *buf = (uint8_t *)buf_in;
   int rem;
   int b1, b2, b3, b4;
 
@@ -5140,25 +5140,25 @@ static int offset2bytes(int nr, char_u *buf)
   b4 = rem / 255 + 1;
 
   if (b4 > 1 || b3 > 0x1f) {    // 4 bytes
-    buf[0] = (char_u)(0xe0 + b4);
-    buf[1] = (char_u)b3;
-    buf[2] = (char_u)b2;
-    buf[3] = (char_u)b1;
+    buf[0] = (uint8_t)(0xe0 + b4);
+    buf[1] = (uint8_t)b3;
+    buf[2] = (uint8_t)b2;
+    buf[3] = (uint8_t)b1;
     return 4;
   }
   if (b3 > 1 || b2 > 0x3f) {   // 3 bytes
-    buf[0] = (char_u)(0xc0 + b3);
-    buf[1] = (char_u)b2;
-    buf[2] = (char_u)b1;
+    buf[0] = (uint8_t)(0xc0 + b3);
+    buf[1] = (uint8_t)b2;
+    buf[2] = (uint8_t)b1;
     return 3;
   }
   if (b2 > 1 || b1 > 0x7f) {   // 2 bytes
-    buf[0] = (char_u)(0x80 + b2);
-    buf[1] = (char_u)b1;
+    buf[0] = (uint8_t)(0x80 + b2);
+    buf[1] = (uint8_t)b1;
     return 2;
   }
   // 1 byte
-  buf[0] = (char_u)b1;
+  buf[0] = (uint8_t)b1;
   return 1;
 }
 
@@ -5342,8 +5342,8 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
           semsg(_("E755: Invalid region in %s"), innames[i]);
           goto theend;
         }
-        spin.si_region_name[i * 2] = (char_u)TOLOWER_ASC(innames[i][len - 2]);
-        spin.si_region_name[i * 2 + 1] = (char_u)TOLOWER_ASC(innames[i][len - 1]);
+        spin.si_region_name[i * 2] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 2]);
+        spin.si_region_name[i * 2 + 1] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 1]);
       }
     }
     spin.si_region_count = incount;
@@ -5599,21 +5599,21 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
   if (!undo) {
     fd = os_fopen(fname, "a");
     if (fd == NULL && new_spf) {
-      char_u *p;
+      char *p;
 
       // We just initialized the 'spellfile' option and can't open the
       // file.  We may need to create the "spell" directory first.  We
       // already checked the runtime directory is writable in
       // init_spellfile().
       if (!dir_of_file_exists(fname)
-          && (p = (char_u *)path_tail_with_sep(fname)) != (char_u *)fname) {
-        int c = *p;
+          && (p = path_tail_with_sep(fname)) != fname) {
+        char c = *p;
 
         // The directory doesn't exist.  Try creating it and opening
         // the file again.
         *p = NUL;
         os_mkdir(fname, 0755);
-        *p = (char_u)c;
+        *p = c;
         fd = os_fopen(fname, "a");
       }
     }
diff --git a/src/nvim/state.c b/src/nvim/state.c
index d02ea46d31..160bc3cd69 100644
--- a/src/nvim/state.c
+++ b/src/nvim/state.c
@@ -92,7 +92,7 @@ getkey:
     }
 
 #ifdef NVIM_LOG_DEBUG
-    char *keyname = key == K_EVENT ? "K_EVENT" : (char *)get_special_key_name(key, mod_mask);
+    char *keyname = key == K_EVENT ? "K_EVENT" : get_special_key_name(key, mod_mask);
     DLOG("input: %s", keyname);
 #endif
 
diff --git a/src/nvim/types.h b/src/nvim/types.h
index d90c623955..0bc2f76078 100644
--- a/src/nvim/types.h
+++ b/src/nvim/types.h
@@ -7,10 +7,6 @@
 // dummy to pass an ACL to a function
 typedef void *vim_acl_T;
 
-// Shorthand for unsigned variables. Many systems, but not all, have u_char
-// already defined, so we use char_u to avoid trouble.
-typedef unsigned char char_u;
-
 // Can hold one decoded UTF-8 character.
 typedef uint32_t u8char_T;