*: Move some dictionary functions to typval.h and use char*

Also fixes buffer reusage in setmatches() and complete().

46 files changed, 2052 insertions, 1831 deletions

diff --git a/src/.asan-blacklist b/src/.asan-blacklist
index 7636f8fa82..928d81bd5a 100644
--- a/src/.asan-blacklist
+++ b/src/.asan-blacklist
@@ -1,3 +1,3 @@
 # multiqueue.h pointer arithmetic is not accepted by asan
 fun:multiqueue_node_data
-fun:dictwatcher_node_data
+fun:tv_dict_watcher_node_data
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index ff45cad8f5..6b17ba1a11 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -88,14 +88,13 @@ bool try_end(Error *err)
 /// @param[out] err Details of an error that may have occurred
 Object dict_get_value(dict_T *dict, String key, Error *err)
 {
-  hashitem_T *hi = hash_find(&dict->dv_hashtab, (char_u *)key.data);
+  dictitem_T *const di = tv_dict_find(dict, key.data, (ptrdiff_t)key.size);
 
-  if (HASHITEM_EMPTY(hi)) {
+  if (di == NULL) {
     api_set_error(err, Validation, _("Key not found"));
     return (Object) OBJECT_INIT;
   }
 
-  dictitem_T *di = dict_lookup(hi);
   return vim_to_object(&di->di_tv);
 }
 
@@ -130,7 +129,7 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
     return rv;
   }
 
-  dictitem_T *di = dict_find(dict, (char_u *)key.data, (int)key.size);
+  dictitem_T *di = tv_dict_find(dict, key.data, (ptrdiff_t)key.size);
 
   if (di != NULL) {
     if (di->di_flags & DI_FLAGS_RO) {
@@ -156,9 +155,7 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
         rv = vim_to_object(&di->di_tv);
       }
       // Delete the entry
-      hashitem_T *hi = hash_find(&dict->dv_hashtab, di->di_key);
-      hash_remove(&dict->dv_hashtab, hi);
-      dictitem_free(di);
+      tv_dict_item_remove(dict, di);
     }
   } else {
     // Update the key
@@ -171,8 +168,8 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
 
     if (di == NULL) {
       // Need to create an entry
-      di = dictitem_alloc((uint8_t *) key.data);
-      dict_add(dict, di);
+      di = tv_dict_item_alloc_len(key.data, key.size);
+      tv_dict_add(dict, di);
     } else {
       // Return the old value
       if (retval) {
@@ -706,7 +703,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
     }
 
     case kObjectTypeDictionary: {
-      dict_T *dict = dict_alloc();
+      dict_T *const dict = tv_dict_alloc();
 
       for (uint32_t i = 0; i < obj.data.dictionary.size; i++) {
         KeyValuePair item = obj.data.dictionary.items[i];
@@ -716,20 +713,20 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
           api_set_error(err, Validation,
                         _("Empty dictionary keys aren't allowed"));
           // cleanup
-          dict_free(dict);
+          tv_dict_free(dict);
           return false;
         }
 
-        dictitem_T *di = dictitem_alloc((uint8_t *)key.data);
+        dictitem_T *const di = tv_dict_item_alloc(key.data);
 
         if (!object_to_vim(item.value, &di->di_tv, err)) {
           // cleanup
-          dictitem_free(di);
-          dict_free(dict);
+          tv_dict_item_free(di);
+          tv_dict_free(dict);
           return false;
         }
 
-        dict_add(dict, di);
+        tv_dict_add(dict, di);
       }
       dict->dv_refcount++;
 
@@ -960,11 +957,7 @@ static void set_option_value_err(char *key,
 {
   char *errmsg;
 
-  if ((errmsg = (char *)set_option_value((uint8_t *)key,
-                                         numval,
-                                         (uint8_t *)stringval,
-                                         opt_flags)))
-  {
+  if ((errmsg = set_option_value(key, numval, stringval, opt_flags))) {
     if (try_end(err)) {
       return;
     }
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 59c0200395..db2f25a2a6 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -185,7 +185,7 @@ Object nvim_eval(String expr, Error *err)
   typval_T *expr_result = eval_expr((char_u *)expr.data, NULL);
 
   if (!expr_result) {
-    api_set_error(err, Exception, _("Failed to evaluate expression"));
+    api_set_error(err, Exception, "Failed to evaluate expression");
   }
 
   if (!try_end(err)) {
diff --git a/src/nvim/ascii.h b/src/nvim/ascii.h
index 44ff540b40..31851a84e6 100644
--- a/src/nvim/ascii.h
+++ b/src/nvim/ascii.h
@@ -8,9 +8,11 @@
 
 // Definitions of various common control characters.
 
-#define CharOrd(x)      ((x) < 'a' ? (x) - 'A' : (x) - 'a')
-#define CharOrdLow(x)   ((x) - 'a')
-#define CharOrdUp(x)    ((x) - 'A')
+#define CharOrd(x)      ((uint8_t)(x) < 'a' \
+                         ? (uint8_t)(x) - 'A'\
+                         : (uint8_t)(x) - 'a')
+#define CharOrdLow(x)   ((uint8_t)(x) - 'a')
+#define CharOrdUp(x)    ((uint8_t)(x) - 'A')
 #define ROT13(c, a)     (((((c) - (a)) + 13) % 26) + (a))
 
 #define NUL             '\000'
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index f7333fead4..0ce9ce073e 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -661,7 +661,7 @@ static void free_buffer(buf_T *buf)
   free_buffer_stuff(buf, true);
   unref_var_dict(buf->b_vars);
   aubuflocal_remove(buf);
-  dict_unref(buf->additional_data);
+  tv_dict_unref(buf->additional_data);
   clear_fmark(&buf->b_last_cursor);
   clear_fmark(&buf->b_last_insert);
   clear_fmark(&buf->b_last_change);
@@ -1481,7 +1481,7 @@ static inline void buf_init_changedtick(buf_T *const buf)
     },
     .di_key = "changedtick",
   };
-  dict_add(buf->b_vars, (dictitem_T *)&buf->changedtick_di);
+  tv_dict_add(buf->b_vars, (dictitem_T *)&buf->changedtick_di);
 }
 
 /// Add a file name to the buffer list.
@@ -1573,7 +1573,7 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
   if (buf != curbuf || curbuf == NULL) {
     buf = xcalloc(1, sizeof(buf_T));
     // init b: variables
-    buf->b_vars = dict_alloc();
+    buf->b_vars = tv_dict_alloc();
     init_var_dict(buf->b_vars, &buf->b_bufvar, VAR_SCOPE);
     buf_init_changedtick(buf);
   }
@@ -5443,8 +5443,8 @@ void buf_open_scratch(handle_T bufnr, char *bufname)
 {
   (void)do_ecmd((int)bufnr, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, NULL);
   (void)setfname(curbuf, (char_u *)bufname, NULL, true);
-  set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL);
-  set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
-  set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
+  set_option_value("bh", 0L, "hide", OPT_LOCAL);
+  set_option_value("bt", 0L, "nofile", OPT_LOCAL);
+  set_option_value("swf", 0L, NULL, OPT_LOCAL);
   RESET_BINDING(curwin);
 }
diff --git a/src/nvim/buffer.h b/src/nvim/buffer.h
index ed3e6ab6cc..c915d373aa 100644
--- a/src/nvim/buffer.h
+++ b/src/nvim/buffer.h
@@ -7,6 +7,7 @@
 #include "nvim/screen.h"  // for StlClickRecord
 #include "nvim/func_attr.h"
 #include "nvim/eval.h"
+#include "nvim/macros.h"
 
 // Values for buflist_getfile()
 enum getf_values {
@@ -91,8 +92,8 @@ static inline void buf_set_changedtick(buf_T *const buf, const int changedtick)
 static inline void buf_set_changedtick(buf_T *const buf, const int changedtick)
 {
 #ifndef NDEBUG
-  dictitem_T *const changedtick_di = dict_find(
-      buf->b_vars, (char_u *)"changedtick", sizeof("changedtick") - 1);
+  dictitem_T *const changedtick_di = tv_dict_find(
+      buf->b_vars, S_LEN("changedtick"));
   assert(changedtick_di != NULL);
   assert(changedtick_di->di_tv.v_type == VAR_NUMBER);
   assert(changedtick_di->di_tv.v_lock == VAR_FIXED);
diff --git a/src/nvim/charset.h b/src/nvim/charset.h
index 8d25b828e5..c69582c4c6 100644
--- a/src/nvim/charset.h
+++ b/src/nvim/charset.h
@@ -5,6 +5,16 @@
 #include "nvim/pos.h"
 #include "nvim/buffer_defs.h"
 
+/// Return the folded-case equivalent of the given character
+///
+/// @param[in]  c  Character to transform.
+///
+/// @return Folded variant.
+#define CH_FOLD(c) \
+    utf_fold((sizeof(c) == sizeof(char)) \
+             ?((int)(uint8_t)(c)) \
+             :((int)(c)))
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "charset.h.generated.h"
 #endif
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 11ade20c1c..ff76abc01f 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -1586,7 +1586,7 @@ static int diff_cmp(char_u *s1, char_u *s2)
   }
 
   if ((diff_flags & DIFF_ICASE) && !(diff_flags & DIFF_IWHITE)) {
-    return mb_stricmp(s1, s2);
+    return mb_stricmp((const char *)s1, (const char *)s2);
   }
 
   // Ignore white space changes and possibly ignore case.
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 77d5b2c816..53b196c61f 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -2094,38 +2094,56 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
 
     xfree(wca);
 
-    return ins_compl_add(IObuff, len, icase, fname, NULL, dir,
-        flags, FALSE);
+    return ins_compl_add(IObuff, len, icase, fname, NULL, true, dir, flags,
+                         false);
   }
-  return ins_compl_add(str, len, icase, fname, NULL, dir, flags, FALSE);
+  return ins_compl_add(str, len, icase, fname, NULL, false, dir, flags, false);
 }
 
-/*
- * Add a match to the list of matches.
- * If the given string is already in the list of completions, then return
- * NOTDONE, otherwise add it to the list and return OK.  If there is an error
- * then FAIL is returned.
- */
-static int
-ins_compl_add (
-    char_u *str,
-    int len,
-    int icase,
-    char_u *fname,
-    char_u **cptext,       /* extra text for popup menu or NULL */
-    int cdir,
-    int flags,
-    int adup                   /* accept duplicate match */
-)
+/// Add a match to the list of matches
+///
+/// @param[in]  str  Match to add.
+/// @param[in]  len  Match length, -1 to use #STRLEN.
+/// @param[in]  icase  Whether case is to be ignored.
+/// @param[in]  fname  File name match comes from. May be NULL.
+/// @param[in]  cptext  Extra text for popup menu. May be NULL. If not NULL,
+///                     must have exactly #CPT_COUNT items.
+/// @param[in]  cptext_allocated  If true, will not copy cptext strings.
+///
+///                               @note Will free strings in case of error.
+///                                     cptext itself will not be freed.
+/// @param[in]  cdir  Completion direction.
+/// @param[in]  adup  True if duplicate matches are to be accepted.
+///
+/// @return NOTDONE if the given string is already in the list of completions,
+///         otherwise it is added to the list and  OK is returned. FAIL will be
+///         returned in case of error.
+static int ins_compl_add(char_u *const str, int len,
+                         const bool icase, char_u *const fname,
+                         char_u *const *const cptext,
+                         const bool cptext_allocated,
+                         const Direction cdir, int flags, const bool adup)
+  FUNC_ATTR_NONNULL_ARG(1)
 {
   compl_T     *match;
-  int dir = (cdir == 0 ? compl_direction : cdir);
+  int dir = (cdir == kDirectionNotSet ? compl_direction : cdir);
 
   os_breakcheck();
-  if (got_int)
+#define FREE_CPTEXT(cptext, cptext_allocated) \
+  do { \
+    if (cptext_allocated) { \
+      for (size_t i = 0; i < CPT_COUNT; i++) { \
+        xfree(cptext[i]); \
+      } \
+    } \
+  } while (0)
+  if (got_int) {
+    FREE_CPTEXT(cptext, cptext_allocated);
     return FAIL;
-  if (len < 0)
+  }
+  if (len < 0) {
     len = (int)STRLEN(str);
+  }
 
   /*
    * If the same match is already present, don't add it.
@@ -2133,10 +2151,12 @@ ins_compl_add (
   if (compl_first_match != NULL && !adup) {
     match = compl_first_match;
     do {
-      if (    !(match->cp_flags & ORIGINAL_TEXT)
-              && STRNCMP(match->cp_str, str, len) == 0
-              && match->cp_str[len] == NUL)
+      if (!(match->cp_flags & ORIGINAL_TEXT)
+          && STRNCMP(match->cp_str, str, len) == 0
+          && match->cp_str[len] == NUL) {
+        FREE_CPTEXT(cptext, cptext_allocated);
         return NOTDONE;
+      }
       match = match->cp_next;
     } while (match != NULL && match != compl_first_match);
   }
@@ -2167,16 +2187,26 @@ ins_compl_add (
   else if (fname != NULL) {
     match->cp_fname = vim_strsave(fname);
     flags |= FREE_FNAME;
-  } else
+  } else {
     match->cp_fname = NULL;
+  }
   match->cp_flags = flags;
 
   if (cptext != NULL) {
     int i;
 
-    for (i = 0; i < CPT_COUNT; ++i)
-      if (cptext[i] != NULL && *cptext[i] != NUL)
-        match->cp_text[i] = vim_strsave(cptext[i]);
+    for (i = 0; i < CPT_COUNT; i++) {
+      if (cptext[i] == NULL) {
+        continue;
+      }
+      if (*cptext[i] != NUL) {
+        match->cp_text[i] = (cptext_allocated
+                             ? cptext[i]
+                             : (char_u *)xstrdup((char *)cptext[i]));
+      } else if (cptext_allocated) {
+        xfree(cptext[i]);
+      }
+    }
   }
 
   /*
@@ -2299,9 +2329,10 @@ static void ins_compl_add_matches(int num_matches, char_u **matches, int icase)
 
   for (i = 0; i < num_matches && add_r != FAIL; i++)
     if ((add_r = ins_compl_add(matches[i], -1, icase,
-             NULL, NULL, dir, 0, FALSE)) == OK)
-      /* if dir was BACKWARD then honor it just once */
+                               NULL, NULL, false, dir, 0, false)) == OK) {
+      // If dir was BACKWARD then honor it just once.
       dir = FORWARD;
+    }
   FreeWild(num_matches, matches);
 }
 
@@ -2365,8 +2396,8 @@ void set_completion(colnr_T startcol, list_T *list)
   /* compl_pattern doesn't need to be set */
   compl_orig_text = vim_strnsave(get_cursor_line_ptr() + compl_col,
                                  compl_length);
-  if (ins_compl_add(compl_orig_text, -1, p_ic, NULL, NULL, 0,
-                    ORIGINAL_TEXT, FALSE) != OK) {
+  if (ins_compl_add(compl_orig_text, -1, p_ic, NULL, NULL, false, 0,
+                    ORIGINAL_TEXT, false) != OK) {
     return;
   }
 
@@ -2888,7 +2919,7 @@ static void ins_compl_clear(void)
   compl_orig_text = NULL;
   compl_enter_selects = FALSE;
   // clear v:completed_item
-  set_vim_var_dict(VV_COMPLETED_ITEM, dict_alloc());
+  set_vim_var_dict(VV_COMPLETED_ITEM, tv_dict_alloc());
 }
 
 /// Check that Insert completion is active.
@@ -3486,7 +3517,7 @@ expand_by_function (
 
 theend:
   if (matchdict != NULL) {
-    dict_unref(matchdict);
+    tv_dict_unref(matchdict);
   }
   if (matchlist != NULL) {
     tv_list_unref(matchlist);
@@ -3519,53 +3550,60 @@ static void ins_compl_add_dict(dict_T *dict)
   dictitem_T  *di_refresh;
   dictitem_T  *di_words;
 
-  /* Check for optional "refresh" item. */
-  compl_opt_refresh_always = FALSE;
-  di_refresh = dict_find(dict, (char_u *)"refresh", 7);
+  // Check for optional "refresh" item.
+  compl_opt_refresh_always = false;
+  di_refresh = tv_dict_find(dict, S_LEN("refresh"));
   if (di_refresh != NULL && di_refresh->di_tv.v_type == VAR_STRING) {
-    char_u  *v = di_refresh->di_tv.vval.v_string;
+    const char *v = (const char *)di_refresh->di_tv.vval.v_string;
 
-    if (v != NULL && STRCMP(v, (char_u *)"always") == 0)
-      compl_opt_refresh_always = TRUE;
+    if (v != NULL && strcmp(v, "always") == 0) {
+      compl_opt_refresh_always = true;
+    }
   }
 
-  /* Add completions from a "words" list. */
-  di_words = dict_find(dict, (char_u *)"words", 5);
-  if (di_words != NULL && di_words->di_tv.v_type == VAR_LIST)
+  // Add completions from a "words" list.
+  di_words = tv_dict_find(dict, S_LEN("words"));
+  if (di_words != NULL && di_words->di_tv.v_type == VAR_LIST) {
     ins_compl_add_list(di_words->di_tv.vval.v_list);
+  }
 }
 
-/*
- * Add a match to the list of matches from a typeval_T.
- * If the given string is already in the list of completions, then return
- * NOTDONE, otherwise add it to the list and return OK.  If there is an error
- * then FAIL is returned.
- */
-int ins_compl_add_tv(typval_T *tv, int dir)
-{
-  char_u      *word;
-  int icase = FALSE;
-  int adup = FALSE;
-  int aempty = FALSE;
-  char_u      *(cptext[CPT_COUNT]);
+/// Add a match to the list of matches from VimL object
+///
+/// @param[in]  tv  Object to get matches from.
+/// @param[in]  dir  Completion direction.
+///
+/// @return NOTDONE if the given string is already in the list of completions,
+///         otherwise it is added to the list and  OK is returned. FAIL will be
+///         returned in case of error.
+int ins_compl_add_tv(typval_T *const tv, const Direction dir)
+  FUNC_ATTR_NONNULL_ALL
+{
+  const char *word;
+  bool icase = false;
+  bool adup = false;
+  bool aempty = false;
+  char *(cptext[CPT_COUNT]);
 
   if (tv->v_type == VAR_DICT && tv->vval.v_dict != NULL) {
-    word = get_dict_string(tv->vval.v_dict, "word", false);
-    cptext[CPT_ABBR] = get_dict_string(tv->vval.v_dict, "abbr", false);
-    cptext[CPT_MENU] = get_dict_string(tv->vval.v_dict, "menu", false);
-    cptext[CPT_KIND] = get_dict_string(tv->vval.v_dict, "kind", false);
-    cptext[CPT_INFO] = get_dict_string(tv->vval.v_dict, "info", false);
-
-    icase = get_dict_number(tv->vval.v_dict, "icase");
-    adup = get_dict_number(tv->vval.v_dict, "dup");
-    aempty = get_dict_number(tv->vval.v_dict, "empty");
+    word = tv_dict_get_string(tv->vval.v_dict, "word", false);
+    cptext[CPT_ABBR] = tv_dict_get_string(tv->vval.v_dict, "abbr", true);
+    cptext[CPT_MENU] = tv_dict_get_string(tv->vval.v_dict, "menu", true);
+    cptext[CPT_KIND] = tv_dict_get_string(tv->vval.v_dict, "kind", true);
+    cptext[CPT_INFO] = tv_dict_get_string(tv->vval.v_dict, "info", true);
+
+    icase = (bool)tv_dict_get_number(tv->vval.v_dict, "icase");
+    adup = (bool)tv_dict_get_number(tv->vval.v_dict, "dup");
+    aempty = (bool)tv_dict_get_number(tv->vval.v_dict, "empty");
   } else {
-    word = get_tv_string_chk(tv);
+    word = (const char *)get_tv_string_chk(tv);
     memset(cptext, 0, sizeof(cptext));
   }
-  if (word == NULL || (!aempty && *word == NUL))
+  if (word == NULL || (!aempty && *word == NUL)) {
     return FAIL;
-  return ins_compl_add(word, -1, icase, NULL, cptext, dir, 0, adup);
+  }
+  return ins_compl_add((char_u *)word, -1, icase, NULL,
+                       (char_u **)cptext, true, dir, 0, adup);
 }
 
 /*
@@ -3980,7 +4018,7 @@ static void ins_compl_delete(void)
   // causes flicker, thus we can't do that.
   changed_cline_bef_curs();
   // clear v:completed_item
-  set_vim_var_dict(VV_COMPLETED_ITEM, dict_alloc());
+  set_vim_var_dict(VV_COMPLETED_ITEM, tv_dict_alloc());
 }
 
 // Insert the new text being completed.
@@ -3995,7 +4033,7 @@ static void ins_compl_insert(int in_compl_func)
 
   // Set completed item.
   // { word, abbr, menu, kind, info }
-  dict_T *dict = dict_alloc();
+  dict_T *dict = tv_dict_alloc();
   dict_add_nr_str(dict, "word", 0L,
                   EMPTY_IF_NULL(compl_shown_match->cp_str));
   dict_add_nr_str(dict, "abbr", 0L,
@@ -4667,8 +4705,8 @@ static int ins_complete(int c, bool enable_pum)
     /* Always add completion for the original text. */
     xfree(compl_orig_text);
     compl_orig_text = vim_strnsave(line + compl_col, compl_length);
-    if (ins_compl_add(compl_orig_text, -1, p_ic, NULL, NULL, 0,
-                      ORIGINAL_TEXT, FALSE) != OK) {
+    if (ins_compl_add(compl_orig_text, -1, p_ic, NULL, NULL, false, 0,
+                      ORIGINAL_TEXT, false) != OK) {
       xfree(compl_pattern);
       compl_pattern = NULL;
       xfree(compl_orig_text);
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 03d6eef9e3..5015deead7 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -97,6 +97,7 @@
 #include "nvim/eval/typval.h"
 #include "nvim/eval/executor.h"
 #include "nvim/eval/gc.h"
+#include "nvim/macros.h"
 
 // TODO(ZyX-I): Remove DICT_MAXNEST, make users be non-recursive instead
 
@@ -432,21 +433,6 @@ static ScopeDictDictItem vimvars_var;
 /// v: hashtab
 #define vimvarht  vimvardict.dv_hashtab
 
-typedef enum {
-  kCallbackNone,
-  kCallbackFuncref,
-  kCallbackPartial,
-} CallbackType;
-
-typedef struct {
-  union {
-    char_u *funcref;
-    partial_T *partial;
-  } data;
-  CallbackType type;
-} Callback;
-#define CALLBACK_NONE ((Callback){ .type = kCallbackNone })
-
 typedef struct {
   union {
     LibuvProcess uv;
@@ -464,13 +450,6 @@ typedef struct {
   MultiQueue *events;
 } TerminalJobData;
 
-typedef struct dict_watcher {
-  Callback callback;
-  char *key_pattern;
-  QUEUE node;
-  bool busy;  // prevent recursion if the dict is changed in the callback
-} DictWatcher;
-
 typedef struct {
   TerminalJobData *data;
   Callback *callback;
@@ -596,19 +575,19 @@ void eval_init(void)
   }
   vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
 
-  dict_T *const msgpack_types_dict = dict_alloc();
+  dict_T *const msgpack_types_dict = tv_dict_alloc();
   for (size_t i = 0; i < ARRAY_SIZE(msgpack_type_names); i++) {
     list_T *const type_list = tv_list_alloc();
     type_list->lv_lock = VAR_FIXED;
     type_list->lv_refcount = 1;
-    dictitem_T *const di = dictitem_alloc((char_u *)msgpack_type_names[i]);
+    dictitem_T *const di = tv_dict_item_alloc(msgpack_type_names[i]);
     di->di_flags |= DI_FLAGS_RO|DI_FLAGS_FIX;
     di->di_tv = (typval_T) {
       .v_type = VAR_LIST,
       .vval = { .v_list = type_list, },
     };
     eval_msgpack_type_lists[i] = type_list;
-    if (dict_add(msgpack_types_dict, di) == FAIL) {
+    if (tv_dict_add(msgpack_types_dict, di) == FAIL) {
       // There must not be duplicate items in this dictionary by definition.
       assert(false);
     }
@@ -616,9 +595,9 @@ void eval_init(void)
   msgpack_types_dict->dv_lock = VAR_FIXED;
 
   set_vim_var_dict(VV_MSGPACK_TYPES, msgpack_types_dict);
-  set_vim_var_dict(VV_COMPLETED_ITEM, dict_alloc());
+  set_vim_var_dict(VV_COMPLETED_ITEM, tv_dict_alloc());
 
-  dict_T *v_event = dict_alloc();
+  dict_T *v_event = tv_dict_alloc();
   v_event->dv_lock = VAR_FIXED;
   set_vim_var_dict(VV_EVENT, v_event);
   set_vim_var_list(VV_ERRORS, tv_list_alloc());
@@ -745,7 +724,7 @@ void set_internal_string_var(char_u *name, char_u *value)
 
   tvp->v_type = VAR_STRING;
   tvp->vval.v_string = val;
-  set_var(name, tvp, FALSE);
+  set_var((const char *)name, tvp, false);
   free_tv(tvp);
 }
 
@@ -1689,7 +1668,7 @@ static void list_hashtable_vars(hashtab_T *ht, const char *prefix, int empty,
   for (hi = ht->ht_array; todo > 0 && !got_int; ++hi) {
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
-      di = HI2DI(hi);
+      di = TV_DICT_HI2DI(hi);
       if (empty || di->di_tv.v_type != VAR_STRING
           || di->di_tv.vval.v_string != NULL) {
         list_one_var(di, prefix, first);
@@ -1951,7 +1930,7 @@ ex_let_one (
         }
       }
       if (s != NULL) {
-        set_option_value(arg, n, s, opt_flags);
+        set_option_value((const char *)arg, n, (char *)s, opt_flags);
         arg_end = (char_u *)p;
       }
       *p = c1;
@@ -2220,7 +2199,7 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
       }
       lp->ll_list = NULL;
       lp->ll_dict = lp->ll_tv->vval.v_dict;
-      lp->ll_di = dict_find(lp->ll_dict, key, len);
+      lp->ll_di = tv_dict_find(lp->ll_dict, (const char *)key, len);
 
       /* When assigning to a scope dictionary check that a function and
        * variable name is valid (only variable name unless it is l: or
@@ -2232,16 +2211,19 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
         if (len != -1) {
           prevval = key[len];
           key[len] = NUL;
-        } else
-          prevval = 0;           /* avoid compiler warning */
-        wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE
-                 && rettv->v_type == VAR_FUNC
-                 && var_check_func_name(key, lp->ll_di == NULL))
-                || !valid_varname(key);
-        if (len != -1)
+        } else {
+          prevval = 0;  // Avoid compiler warning.
+        }
+        wrong = ((lp->ll_dict->dv_scope == VAR_DEF_SCOPE
+                  && rettv->v_type == VAR_FUNC
+                  && !var_check_func_name((const char *)key, lp->ll_di == NULL))
+                 || !valid_varname((const char *)key));
+        if (len != -1) {
           key[len] = prevval;
-        if (wrong)
+        }
+        if (wrong) {
           return NULL;
+        }
       }
 
       if (lp->ll_di == NULL) {
@@ -2391,12 +2373,12 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
                  && !tv_check_lock(di->di_tv.v_lock, (const char *)lp->ll_name,
                                    STRLEN(lp->ll_name))))
             && eexe_mod_op(&tv, rettv, (const char *)op) == OK) {
-          set_var(lp->ll_name, &tv, false);
+          set_var((const char *)lp->ll_name, &tv, false);
         }
         tv_clear(&tv);
       }
     } else {
-      set_var(lp->ll_name, rettv, copy);
+      set_var((const char *)lp->ll_name, rettv, copy);
     }
     *endp = cc;
   } else if (tv_check_lock(lp->ll_newkey == NULL
@@ -2450,26 +2432,20 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
              : lp->ll_n1 != lp->ll_n2)
       EMSG(_("E711: List value has not enough items"));
   } else {
-    typval_T oldtv;
+    typval_T oldtv = TV_INITIAL_VALUE;
     dict_T *dict = lp->ll_dict;
-    bool watched = is_watched(dict);
+    bool watched = tv_dict_is_watched(dict);
 
-    if (watched) {
-      init_tv(&oldtv);
-    }
-
-    /*
-     * Assign to a List or Dictionary item.
-     */
+    // Assign to a List or Dictionary item.
     if (lp->ll_newkey != NULL) {
       if (op != NULL && *op != '=') {
         EMSG2(_(e_letwrong), op);
         return;
       }
 
-      /* Need to add an item to the Dictionary. */
-      di = dictitem_alloc(lp->ll_newkey);
-      if (dict_add(lp->ll_tv->vval.v_dict, di) == FAIL) {
+      // Need to add an item to the Dictionary.
+      di = tv_dict_item_alloc((const char *)lp->ll_newkey);
+      if (tv_dict_add(lp->ll_tv->vval.v_dict, di) == FAIL) {
         xfree(di);
         return;
       }
@@ -2493,16 +2469,16 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
     } else {
       *lp->ll_tv = *rettv;
       lp->ll_tv->v_lock = 0;
-      init_tv(rettv);
+      tv_init(rettv);
     }
 
 notify:
     if (watched) {
       if (oldtv.v_type == VAR_UNKNOWN) {
-        dictwatcher_notify(dict, (char *)lp->ll_newkey, lp->ll_tv, NULL);
+        tv_dict_watcher_notify(dict, (char *)lp->ll_newkey, lp->ll_tv, NULL);
       } else {
         dictitem_T *di = lp->ll_di;
-        dictwatcher_notify(dict, (char *)di->di_key, lp->ll_tv, &oldtv);
+        tv_dict_watcher_notify(dict, (char *)di->di_key, lp->ll_tv, &oldtv);
         tv_clear(&oldtv);
       }
     }
@@ -2806,7 +2782,7 @@ void ex_call(exarg_T *eap)
   }
 
 end:
-  dict_unref(fudi.fd_dict);
+  tv_dict_unref(fudi.fd_dict);
   xfree(tofree);
 }
 
@@ -2944,7 +2920,7 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
       // unlet a Dictionary item.
       dict_T *d = lp->ll_dict;
       dictitem_T *di = lp->ll_di;
-      bool watched = is_watched(d);
+      bool watched = tv_dict_is_watched(d);
       char *key = NULL;
       typval_T oldtv;
 
@@ -2954,10 +2930,10 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
         key = xstrdup((char *)di->di_key);
       }
 
-      dictitem_remove(d, di);
+      tv_dict_item_remove(d, di);
 
       if (watched) {
-        dictwatcher_notify(d, key, NULL, &oldtv);
+        tv_dict_watcher_notify(d, key, NULL, &oldtv);
         tv_clear(&oldtv);
         xfree(key);
       }
@@ -3005,7 +2981,7 @@ int do_unlet(char_u *name, int forceit)
       hi = find_hi_in_scoped_ht((const char *)name, &ht);
     }
     if (hi != NULL && !HASHITEM_EMPTY(hi)) {
-      di = HI2DI(hi);
+      di = TV_DICT_HI2DI(hi);
       if (var_check_fixed(di->di_flags, (const char *)name, STRLEN(name))
           || var_check_ro(di->di_flags, (const char *)name, STRLEN(name))
           || tv_check_lock(d->dv_lock, (const char *)name, STRLEN(name))) {
@@ -3018,7 +2994,7 @@ int do_unlet(char_u *name, int forceit)
       }
 
       typval_T oldtv;
-      bool watched = is_watched(dict);
+      bool watched = tv_dict_is_watched(dict);
 
       if (watched) {
         copy_tv(&di->di_tv, &oldtv);
@@ -3027,7 +3003,7 @@ int do_unlet(char_u *name, int forceit)
       delete_var(ht, hi);
 
       if (watched) {
-        dictwatcher_notify(dict, (char *)varname, NULL, &oldtv);
+        tv_dict_watcher_notify(dict, (char *)varname, NULL, &oldtv);
         tv_clear(&oldtv);
       }
       return OK;
@@ -3102,18 +3078,12 @@ static int do_lock_var(lval_T *lp, char_u *name_end, const int deep,
  */
 void del_menutrans_vars(void)
 {
-  hashitem_T  *hi;
-  int todo;
-
   hash_lock(&globvarht);
-  todo = (int)globvarht.ht_used;
-  for (hi = globvarht.ht_array; todo > 0 && !got_int; ++hi) {
-    if (!HASHITEM_EMPTY(hi)) {
-      --todo;
-      if (STRNCMP(HI2DI(hi)->di_key, "menutrans_", 10) == 0)
-        delete_var(&globvarht, hi);
+  HASHTAB_ITER(&globvarht, hi, {
+    if (STRNCMP(hi->hi_key, "menutrans_", 10) == 0) {
+      delete_var(&globvarht, hi);
     }
-  }
+  });
   hash_unlock(&globvarht);
 }
 
@@ -3659,11 +3629,12 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
           tv_clear(&var2);
           return FAIL;
         } else {
-          /* Compare two Dictionaries for being equal or unequal. */
-          n1 = dict_equal(rettv->vval.v_dict, var2.vval.v_dict,
-              ic, FALSE);
-          if (type == TYPE_NEQUAL)
+          // Compare two Dictionaries for being equal or unequal.
+          n1 = tv_dict_equal(rettv->vval.v_dict, var2.vval.v_dict,
+                             ic, false);
+          if (type == TYPE_NEQUAL) {
             n1 = !n1;
+          }
         }
       } else if (rettv->v_type == VAR_FUNC || var2.v_type == VAR_FUNC
                  || rettv->v_type == VAR_PARTIAL
@@ -3749,11 +3720,12 @@ static int eval4(char_u **arg, typval_T *rettv, int evaluate)
       } else {
         s1 = get_tv_string_buf(rettv, buf1);
         s2 = get_tv_string_buf(&var2, buf2);
-        if (type != TYPE_MATCH && type != TYPE_NOMATCH)
-          i = ic ? mb_stricmp(s1, s2) : STRCMP(s1, s2);
-        else
+        if (type != TYPE_MATCH && type != TYPE_NOMATCH) {
+          i = mb_strcmp_ic((bool)ic, (const char *)s1, (const char *)s2);
+        } else {
           i = 0;
-        n1 = FALSE;
+        }
+        n1 = false;
         switch (type) {
         case TYPE_EQUAL:    n1 = (i == 0); break;
         case TYPE_NEQUAL:   n1 = (i != 0); break;
@@ -4355,11 +4327,11 @@ eval_index (
     int verbose                    /* give error messages */
 )
 {
-  int empty1 = FALSE, empty2 = FALSE;
-  typval_T var1, var2;
+  bool empty1 = false;
+  bool empty2 = false;
   long n1, n2 = 0;
   long len = -1;
-  int range = FALSE;
+  int range = false;
   char_u      *s;
   char_u      *key = NULL;
 
@@ -4397,8 +4369,8 @@ eval_index (
     }
   }
 
-  init_tv(&var1);
-  init_tv(&var2);
+  typval_T var1 = TV_INITIAL_VALUE;
+  typval_T var2 = TV_INITIAL_VALUE;
   if (**arg == '.') {
     /*
      * dict.name
@@ -4576,7 +4548,7 @@ eval_index (
           }
         }
 
-        item = dict_find(rettv->vval.v_dict, key, (int)len);
+        item = tv_dict_find(rettv->vval.v_dict, (const char *)key, len);
 
         if (item == NULL && verbose) {
           emsgf(_(e_dictkey), key);
@@ -4868,7 +4840,7 @@ static void partial_free(partial_T *pt)
     tv_clear(&pt->pt_argv[i]);
   }
   xfree(pt->pt_argv);
-  dict_unref(pt->pt_dict);
+  tv_dict_unref(pt->pt_dict);
   if (pt->pt_name != NULL) {
     func_unref(pt->pt_name);
     xfree(pt->pt_name);
@@ -4940,64 +4912,7 @@ failret:
   return OK;
 }
 
-
-// TODO(ZyX-I): move to eval/typval
-
-/*
- * Return the dictitem that an entry in a hashtable points to.
- */
-dictitem_T *dict_lookup(hashitem_T *hi)
-{
-  return HI2DI(hi);
-}
-
-// TODO(ZyX-I): move to eval/typval
-
-/*
- * Return TRUE when two dictionaries have exactly the same key/values.
- */
-static int 
-dict_equal (
-    dict_T *d1,
-    dict_T *d2,
-    int ic,                 /* ignore case for strings */
-    int recursive             /* TRUE when used recursively */
-)
-{
-  hashitem_T  *hi;
-  dictitem_T  *item2;
-  int todo;
-
-  if (d1 == NULL && d2 == NULL) {
-    return true;
-  }
-  if (d1 == NULL || d2 == NULL) {
-    return false;
-  }
-  if (d1 == d2) {
-    return true;
-  }
-  if (dict_len(d1) != dict_len(d2)) {
-    return false;
-  }
-
-  todo = (int)d1->dv_hashtab.ht_used;
-  for (hi = d1->dv_hashtab.ht_array; todo > 0; ++hi) {
-    if (!HASHITEM_EMPTY(hi)) {
-      item2 = dict_find(d2, hi->hi_key, -1);
-      if (item2 == NULL)
-        return FALSE;
-      if (!tv_equal(&HI2DI(hi)->di_tv, &item2->di_tv, ic, recursive))
-        return FALSE;
-      --todo;
-    }
-  }
-  return TRUE;
-}
-
-static int tv_equal_recurse_limit;
-
-static bool func_equal(
+bool func_equal(
     typval_T *tv1,
     typval_T *tv2,
     bool ic         // ignore case
@@ -5032,7 +4947,7 @@ static bool func_equal(
     if (d1 != d2) {
       return false;
     }
-  } else if (!dict_equal(d1, d2, ic, true)) {
+  } else if (!tv_dict_equal(d1, d2, ic, true)) {
     return false;
   }
 
@@ -5051,90 +4966,6 @@ static bool func_equal(
   return true;
 }
 
-/*
- * Return TRUE if "tv1" and "tv2" have the same value.
- * Compares the items just like "==" would compare them, but strings and
- * numbers are different.  Floats and numbers are also different.
- */
-int tv_equal(
-    typval_T *tv1,
-    typval_T *tv2,
-    int ic,                     /* ignore case */
-    int recursive              /* TRUE when used recursively */
-)
-{
-  char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
-  char_u      *s1, *s2;
-  static int recursive_cnt = 0;             /* catch recursive loops */
-  int r;
-
-  /* Catch lists and dicts that have an endless loop by limiting
-   * recursiveness to a limit.  We guess they are equal then.
-   * A fixed limit has the problem of still taking an awful long time.
-   * Reduce the limit every time running into it. That should work fine for
-   * deeply linked structures that are not recursively linked and catch
-   * recursiveness quickly. */
-  if (!recursive)
-    tv_equal_recurse_limit = 1000;
-  if (recursive_cnt >= tv_equal_recurse_limit) {
-    --tv_equal_recurse_limit;
-    return TRUE;
-  }
-
-  // For VAR_FUNC and VAR_PARTIAL compare the function name, bound dict and
-  // arguments.
-  if ((tv1->v_type == VAR_FUNC
-       || (tv1->v_type == VAR_PARTIAL && tv1->vval.v_partial != NULL))
-      && (tv2->v_type == VAR_FUNC
-          || (tv2->v_type == VAR_PARTIAL && tv2->vval.v_partial != NULL))) {
-    recursive_cnt++;
-    r = func_equal(tv1, tv2, ic);
-    recursive_cnt--;
-    return r;
-  }
-  if (tv1->v_type != tv2->v_type) {
-    return false;
-  }
-
-  switch (tv1->v_type) {
-  case VAR_LIST:
-    recursive_cnt++;
-    r = tv_list_equal(tv1->vval.v_list, tv2->vval.v_list, ic, true);
-    recursive_cnt--;
-    return r;
-
-  case VAR_DICT:
-    ++recursive_cnt;
-    r = dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic, TRUE);
-    --recursive_cnt;
-    return r;
-
-  case VAR_NUMBER:
-    return tv1->vval.v_number == tv2->vval.v_number;
-
-  case VAR_FLOAT:
-    return tv1->vval.v_float == tv2->vval.v_float;
-
-  case VAR_STRING:
-    s1 = get_tv_string_buf(tv1, buf1);
-    s2 = get_tv_string_buf(tv2, buf2);
-    return (ic ? mb_stricmp(s1, s2) : STRCMP(s1, s2)) == 0;
-
-  case VAR_SPECIAL:
-    return tv1->vval.v_special == tv2->vval.v_special;
-
-  case VAR_FUNC:
-  case VAR_PARTIAL:
-  case VAR_UNKNOWN:
-    // VAR_UNKNOWN can be the result of an invalid expression, let’s say it does
-    // not equal anything, not even self.
-    return false;
-  }
-
-  assert(false);
-  return false;
-}
-
 /// Get next (unique) copy ID
 ///
 /// Used for traversing nested structures e.g. when serializing them or garbage
@@ -5400,7 +5231,7 @@ static int free_unref_items(int copyID)
       // Free the Dictionary and ordinary items it contains, but don't
       // recurse into Lists and Dictionaries, they will be in the list
       // of dicts or list of lists.
-      dict_free_contents(dd);
+      tv_dict_free_contents(dd);
       did_free = true;
     }
   }
@@ -5423,7 +5254,7 @@ static int free_unref_items(int copyID)
   for (dd = gc_first_dict; dd != NULL; dd = dd_next) {
     dd_next = dd->dv_used_next;
     if ((dd->dv_copyID & COPYID_MASK) != (copyID & COPYID_MASK)) {
-      dict_free_dict(dd);
+      tv_dict_free_dict(dd);
     }
   }
 
@@ -5460,14 +5291,10 @@ bool set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack)
       // Mark each item in the hashtab.  If the item contains a hashtab
       // it is added to ht_stack, if it contains a list it is added to
       // list_stack.
-      int todo = (int)cur_ht->ht_used;
-      for (hashitem_T *hi = cur_ht->ht_array; todo > 0; ++hi) {
-        if (!HASHITEM_EMPTY(hi)) {
-          --todo;
-          abort = abort || set_ref_in_item(&HI2DI(hi)->di_tv, copyID, &ht_stack,
-                                           list_stack);
-        }
-      }
+      HASHTAB_ITER(cur_ht, hi, {
+        abort = abort || set_ref_in_item(
+            &TV_DICT_HI2DI(hi)->di_tv, copyID, &ht_stack, list_stack);
+      });
     }
 
     if (ht_stack == NULL) {
@@ -5559,7 +5386,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack,
         QUEUE *w = NULL;
         DictWatcher *watcher = NULL;
         QUEUE_FOREACH(w, &dd->watchers) {
-          watcher = dictwatcher_node_data(w);
+          watcher = tv_dict_watcher_node_data(w);
           set_ref_in_callback(&watcher->callback, copyID, ht_stack, list_stack);
         }
       }
@@ -5704,265 +5531,6 @@ static bool set_ref_in_funccal(funccall_T *fc, int copyID)
   return abort;
 }
 
-/// Allocate an empty header for a dictionary.
-dict_T *dict_alloc(void) FUNC_ATTR_NONNULL_RET
-{
-  dict_T *d = xmalloc(sizeof(dict_T));
-
-  // Add the dict to the list of dicts for garbage collection.
-  if (gc_first_dict != NULL) {
-    gc_first_dict->dv_used_prev = d;
-  }
-  d->dv_used_next = gc_first_dict;
-  d->dv_used_prev = NULL;
-  gc_first_dict = d;
-
-  hash_init(&d->dv_hashtab);
-  d->dv_lock = VAR_UNLOCKED;
-  d->dv_scope = 0;
-  d->dv_refcount = 0;
-  d->dv_copyID = 0;
-  QUEUE_INIT(&d->watchers);
-
-  return d;
-}
-
-/*
- * Allocate an empty dict for a return value.
- */
-static void rettv_dict_alloc(typval_T *rettv)
-{
-  dict_T *d = dict_alloc();
-
-  rettv->vval.v_dict = d;
-  rettv->v_type = VAR_DICT;
-  rettv->v_lock = VAR_UNLOCKED;
-  d->dv_refcount++;
-}
-
-/// Clear all the keys of a Dictionary. "d" remains a valid empty Dictionary.
-///
-/// @param d The Dictionary to clear
-void dict_clear(dict_T *d)
-  FUNC_ATTR_NONNULL_ALL
-{
-  hash_lock(&d->dv_hashtab);
-  assert(d->dv_hashtab.ht_locked > 0);
-
-  size_t todo = d->dv_hashtab.ht_used;
-  for (hashitem_T *hi = d->dv_hashtab.ht_array; todo > 0; hi++) {
-    if (!HASHITEM_EMPTY(hi)) {
-      dictitem_free(HI2DI(hi));
-      hash_remove(&d->dv_hashtab, hi);
-      todo--;
-    }
-  }
-
-  hash_unlock(&d->dv_hashtab);
-}
-
-
-/*
- * Unreference a Dictionary: decrement the reference count and free it when it
- * becomes zero.
- */
-void dict_unref(dict_T *d)
-{
-  if (d != NULL && --d->dv_refcount <= 0) {
-    dict_free(d);
-  }
-}
-
-/// Free a Dictionary, including all items it contains.
-/// Ignores the reference count.
-static void dict_free_contents(dict_T *const d)
-  FUNC_ATTR_NONNULL_ALL
-{
-  // Lock the hashtab, we don't want it to resize while freeing items.
-  hash_lock(&d->dv_hashtab);
-  assert(d->dv_hashtab.ht_locked > 0);
-  size_t todo = (int)d->dv_hashtab.ht_used;
-  for (hashitem_T *hi = d->dv_hashtab.ht_array; todo > 0; hi++) {
-    if (!HASHITEM_EMPTY(hi)) {
-      // Remove the item before deleting it, just in case there is
-      // something recursive causing trouble.
-      dictitem_T *const di = HI2DI(hi);
-      hash_remove(&d->dv_hashtab, hi);
-      dictitem_free(di);
-      todo--;
-    }
-  }
-
-  while (!QUEUE_EMPTY(&d->watchers)) {
-    QUEUE *w = QUEUE_HEAD(&d->watchers);
-    DictWatcher *watcher = dictwatcher_node_data(w);
-    QUEUE_REMOVE(w);
-    dictwatcher_free(watcher);
-  }
-
-  hash_clear(&d->dv_hashtab);
-}
-
-static void dict_free_dict(dict_T *d)
-  FUNC_ATTR_NONNULL_ALL
-{
-  // Remove the dict from the list of dicts for garbage collection.
-  if (d->dv_used_prev == NULL) {
-    gc_first_dict = d->dv_used_next;
-  } else {
-    d->dv_used_prev->dv_used_next = d->dv_used_next;
-  }
-  if (d->dv_used_next != NULL) {
-    d->dv_used_next->dv_used_prev = d->dv_used_prev;
-  }
-
-  xfree(d);
-}
-
-void dict_free(dict_T *d)
-  FUNC_ATTR_NONNULL_ALL
-{
-  if (!tv_in_free_unref_items) {
-    dict_free_contents(d);
-    dict_free_dict(d);
-  }
-}
-
-/*
- * Allocate a Dictionary item.
- * The "key" is copied to the new item.
- * Note that the value of the item "di_tv" still needs to be initialized!
- */
-dictitem_T *dictitem_alloc(char_u *key) FUNC_ATTR_NONNULL_RET
-{
-  dictitem_T *di = xmalloc(offsetof(dictitem_T, di_key) + STRLEN(key) + 1);
-#ifndef __clang_analyzer__
-  STRCPY(di->di_key, key);
-#endif
-  di->di_flags = DI_FLAGS_ALLOC;
-  return di;
-}
-
-/*
- * Make a copy of a Dictionary item.
- */
-static dictitem_T *dictitem_copy(dictitem_T *org) FUNC_ATTR_NONNULL_RET
-{
-  dictitem_T *di = xmalloc(sizeof(dictitem_T) + STRLEN(org->di_key));
-
-  STRCPY(di->di_key, org->di_key);
-  di->di_flags = DI_FLAGS_ALLOC;
-  copy_tv(&org->di_tv, &di->di_tv);
-
-  return di;
-}
-
-/*
- * Remove item "item" from Dictionary "dict" and free it.
- */
-static void dictitem_remove(dict_T *dict, dictitem_T *item)
-{
-  hashitem_T  *hi;
-
-  hi = hash_find(&dict->dv_hashtab, item->di_key);
-  if (HASHITEM_EMPTY(hi)) {
-    EMSG2(_(e_intern2), "dictitem_remove()");
-  } else {
-    hash_remove(&dict->dv_hashtab, hi);
-  }
-  dictitem_free(item);
-}
-
-/*
- * Free a dict item.  Also clears the value.
- */
-void dictitem_free(dictitem_T *item)
-{
-  tv_clear(&item->di_tv);
-  if (item->di_flags & DI_FLAGS_ALLOC) {
-    xfree(item);
-  }
-}
-
-/// Make a copy of dictionary
-///
-/// @param[in]  conv  If non-NULL, then all internal strings will be converted.
-/// @param[in]  orig  Original dictionary to copy.
-/// @param[in]  deep  If false, then shallow copy will be done.
-/// @param[in]  copyID  See var_item_copy().
-///
-/// @return Copied dictionary. May be NULL in case original dictionary is NULL
-///         or some failure happens. The refcount of the new dictionary is set
-///         to 1.
-static dict_T *dict_copy(const vimconv_T *const conv,
-                         dict_T *const orig,
-                         const bool deep,
-                         const int copyID)
-{
-  dictitem_T  *di;
-  int todo;
-  hashitem_T  *hi;
-
-  if (orig == NULL)
-    return NULL;
-
-  dict_T *copy = dict_alloc();
-  {
-    if (copyID != 0) {
-      orig->dv_copyID = copyID;
-      orig->dv_copydict = copy;
-    }
-    todo = (int)orig->dv_hashtab.ht_used;
-    for (hi = orig->dv_hashtab.ht_array; todo > 0 && !got_int; ++hi) {
-      if (!HASHITEM_EMPTY(hi)) {
-        --todo;
-
-        if (conv == NULL || conv->vc_type == CONV_NONE) {
-          di = dictitem_alloc(hi->hi_key);
-        } else {
-          char *const key = (char *) string_convert((vimconv_T *) conv,
-                                                    hi->hi_key, NULL);
-          if (key == NULL) {
-            di = dictitem_alloc(hi->hi_key);
-          } else {
-            di = dictitem_alloc((char_u *) key);
-            xfree(key);
-          }
-        }
-        if (deep) {
-          if (var_item_copy(conv, &HI2DI(hi)->di_tv, &di->di_tv, deep,
-                            copyID) == FAIL) {
-            xfree(di);
-            break;
-          }
-        } else
-          copy_tv(&HI2DI(hi)->di_tv, &di->di_tv);
-        if (dict_add(copy, di) == FAIL) {
-          dictitem_free(di);
-          break;
-        }
-      }
-    }
-
-    ++copy->dv_refcount;
-    if (todo > 0) {
-      dict_unref(copy);
-      copy = NULL;
-    }
-  }
-
-  return copy;
-}
-
-/*
- * Add item "item" to Dictionary "d".
- * Returns FAIL when key already exists.
- */
-int dict_add(dict_T *d, dictitem_T *item)
-{
-  return hash_add(&d->dv_hashtab, item->di_key);
-}
-
 /*
  * Add a number or string entry to dictionary "d".
  * When "str" is NULL use number "nr", otherwise use "str".
@@ -5972,7 +5540,7 @@ int dict_add_nr_str(dict_T *d, char *key, long nr, char_u *str)
 {
   dictitem_T  *item;
 
-  item = dictitem_alloc((char_u *)key);
+  item = tv_dict_item_alloc(key);
   item->di_tv.v_lock = 0;
   if (str == NULL) {
     item->di_tv.v_type = VAR_NUMBER;
@@ -5981,8 +5549,8 @@ int dict_add_nr_str(dict_T *d, char *key, long nr, char_u *str)
     item->di_tv.v_type = VAR_STRING;
     item->di_tv.vval.v_string = vim_strsave(str);
   }
-  if (dict_add(d, item) == FAIL) {
-    dictitem_free(item);
+  if (tv_dict_add(d, item) == FAIL) {
+    tv_dict_item_free(item);
     return FAIL;
   }
   return OK;
@@ -5994,13 +5562,13 @@ int dict_add_nr_str(dict_T *d, char *key, long nr, char_u *str)
  */
 int dict_add_list(dict_T *d, char *key, list_T *list)
 {
-  dictitem_T *item = dictitem_alloc((char_u *)key);
+  dictitem_T *item = tv_dict_item_alloc(key);
 
   item->di_tv.v_lock = 0;
   item->di_tv.v_type = VAR_LIST;
   item->di_tv.vval.v_list = list;
-  if (dict_add(d, item) == FAIL) {
-    dictitem_free(item);
+  if (tv_dict_add(d, item) == FAIL) {
+    tv_dict_item_free(item);
     return FAIL;
   }
   ++list->lv_refcount;
@@ -6011,13 +5579,13 @@ int dict_add_list(dict_T *d, char *key, list_T *list)
 /// Returns FAIL when out of memory and when key already exists.
 int dict_add_dict(dict_T *d, char *key, dict_T *dict)
 {
-  dictitem_T *item = dictitem_alloc((char_u *)key);
+  dictitem_T *const item = tv_dict_item_alloc(key);
 
   item->di_tv.v_lock = 0;
   item->di_tv.v_type = VAR_DICT;
   item->di_tv.vval.v_dict = dict;
-  if (dict_add(d, item) == FAIL) {
-    dictitem_free(item);
+  if (tv_dict_add(d, item) == FAIL) {
+    tv_dict_item_free(item);
     return FAIL;
   }
   dict->dv_refcount++;
@@ -6029,60 +5597,12 @@ int dict_add_dict(dict_T *d, char *key, dict_T *dict)
 /// This does not protect against adding new keys to the Dictionary.
 ///
 /// @param dict The dict whose keys should be frozen
-void dict_set_keys_readonly(dict_T *dict)
+void dict_set_keys_readonly(dict_T *const dict)
   FUNC_ATTR_NONNULL_ALL
 {
-  size_t todo = dict->dv_hashtab.ht_used;
-  for (hashitem_T *hi = dict->dv_hashtab.ht_array; todo > 0 ; hi++) {
-    if (HASHITEM_EMPTY(hi)) {
-      continue;
-    }
-    todo--;
-    HI2DI(hi)->di_flags |= DI_FLAGS_RO | DI_FLAGS_FIX;
-  }
-}
-
-/*
- * Get the number of items in a Dictionary.
- */
-static long dict_len(dict_T *d)
-{
-  if (d == NULL)
-    return 0L;
-  return (long)d->dv_hashtab.ht_used;
-}
-
-/*
- * Find item "key[len]" in Dictionary "d".
- * If "len" is negative use strlen(key).
- * Returns NULL when not found.
- */
-dictitem_T *dict_find(dict_T *d, char_u *key, int len)
-{
-#define AKEYLEN 200
-  char_u buf[AKEYLEN];
-  char_u      *akey;
-  char_u      *tofree = NULL;
-  hashitem_T  *hi;
-
-  if (d == NULL) {
-    return NULL;
-  }
-  if (len < 0) {
-    akey = key;
-  } else if (len >= AKEYLEN) {
-    tofree = akey = vim_strnsave(key, len);
-  } else {
-    /* Avoid a malloc/free by using buf[]. */
-    STRLCPY(buf, key, len + 1);
-    akey = buf;
-  }
-
-  hi = hash_find(&d->dv_hashtab, akey);
-  xfree(tofree);
-  if (HASHITEM_EMPTY(hi))
-    return NULL;
-  return HI2DI(hi);
+  TV_DICT_ITER(dict, di, {
+    di->di_flags |= DI_FLAGS_RO | DI_FLAGS_FIX;
+  });
 }
 
 /// Get a function from a dictionary
@@ -6091,7 +5611,7 @@ dictitem_T *dict_find(dict_T *d, char_u *key, int len)
 /// @return true/false on success/failure.
 static bool get_dict_callback(dict_T *d, char *key, Callback *result)
 {
-  dictitem_T *di = dict_find(d, (uint8_t *)key, -1);
+  dictitem_T *const di = tv_dict_find(d, key, -1);
 
   if (di == NULL) {
     result->type = kCallbackNone;
@@ -6113,40 +5633,6 @@ static bool get_dict_callback(dict_T *d, char *key, Callback *result)
   return res;
 }
 
-/// Get a string item from a dictionary.
-///
-/// @param save whether memory should be allocated for the return value
-///             when false a shared buffer is used, can only be used once!
-///
-/// @return the entry or NULL if the entry doesn't exist.
-char_u *get_dict_string(dict_T *d, char *key, bool save)
-{
-  dictitem_T  *di;
-  char_u      *s;
-
-  di = dict_find(d, (char_u *)key, -1);
-  if (di == NULL) {
-    return NULL;
-  }
-  s = get_tv_string(&di->di_tv);
-  if (save) {
-    s = vim_strsave(s);
-  }
-  return s;
-}
-
-/// Get a number item from a dictionary.
-///
-/// @return the entry or 0 if the entry doesn't exist.
-long get_dict_number(dict_T *d, char *key)
-{
-  dictitem_T *di = dict_find(d, (char_u *)key, -1);
-  if (di == NULL) {
-    return 0;
-  }
-  return get_tv_number(&di->di_tv);
-}
-
 /*
  * Allocate a variable for a Dictionary and fill it from "*arg".
  * Return OK or FAIL.  Returns NOTDONE for {expr}.
@@ -6176,7 +5662,7 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
   }
 
   if (evaluate) {
-    d = dict_alloc();
+    d = tv_dict_alloc();
   }
   tvkey.v_type = VAR_UNKNOWN;
   tv.v_type = VAR_UNKNOWN;
@@ -6207,19 +5693,19 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
       goto failret;
     }
     if (evaluate) {
-      item = dict_find(d, key, -1);
+      item = tv_dict_find(d, (const char *)key, -1);
       if (item != NULL) {
         EMSG2(_("E721: Duplicate key in Dictionary: \"%s\""), key);
         tv_clear(&tvkey);
         tv_clear(&tv);
         goto failret;
       }
-      item = dictitem_alloc(key);
+      item = tv_dict_item_alloc((const char *)key);
       tv_clear(&tvkey);
       item->di_tv = tv;
       item->di_tv.v_lock = 0;
-      if (dict_add(d, item) == FAIL) {
-        dictitem_free(item);
+      if (tv_dict_add(d, item) == FAIL) {
+        tv_dict_item_free(item);
       }
     }
 
@@ -6236,7 +5722,7 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
     EMSG2(_("E723: Missing end of Dictionary '}': %s"), *arg);
 failret:
     if (evaluate) {
-      dict_free(d);
+      tv_dict_free(d);
     }
     return FAIL;
   }
@@ -8152,9 +7638,10 @@ static void f_count(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       todo = error ? 0 : (int)d->dv_hashtab.ht_used;
       for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi) {
         if (!HASHITEM_EMPTY(hi)) {
-          --todo;
-          if (tv_equal(&HI2DI(hi)->di_tv, &argvars[1], ic, FALSE))
-            ++n;
+          todo--;
+          if (tv_equal(&TV_DICT_HI2DI(hi)->di_tv, &argvars[1], ic, false)) {
+            n++;
+          }
         }
       }
     }
@@ -8381,7 +7868,7 @@ static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   DictWatcher *watcher = NULL;
   bool matched = false;
   QUEUE_FOREACH(w, &dict->watchers) {
-    watcher = dictwatcher_node_data(w);
+    watcher = tv_dict_watcher_node_data(w);
     if (callback_equal(&watcher->callback, &callback)
         && !strcmp(watcher->key_pattern, key_pattern)) {
       matched = true;
@@ -8397,7 +7884,7 @@ static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   QUEUE_REMOVE(w);
-  dictwatcher_free(watcher);
+  tv_dict_watcher_free(watcher);
 }
 
 /*
@@ -8772,74 +8259,6 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /*
- * Go over all entries in "d2" and add them to "d1".
- * When "action" is "error" then a duplicate key is an error.
- * When "action" is "force" then a duplicate key is overwritten.
- * Otherwise duplicate keys are ignored ("action" is "keep").
- */
-void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
-{
-  dictitem_T  *di1;
-  hashitem_T  *hi2;
-  int todo;
-  bool watched = is_watched(d1);
-  const char *const arg_errmsg = _("extend() argument");
-  const size_t arg_errmsg_len = strlen(arg_errmsg);
-
-  todo = (int)d2->dv_hashtab.ht_used;
-  for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) {
-    if (!HASHITEM_EMPTY(hi2)) {
-      --todo;
-      di1 = dict_find(d1, hi2->hi_key, -1);
-      if (d1->dv_scope != 0) {
-        /* Disallow replacing a builtin function in l: and g:.
-         * Check the key to be valid when adding to any
-         * scope. */
-        if (d1->dv_scope == VAR_DEF_SCOPE
-            && HI2DI(hi2)->di_tv.v_type == VAR_FUNC
-            && var_check_func_name(hi2->hi_key,
-                di1 == NULL))
-          break;
-        if (!valid_varname(hi2->hi_key))
-          break;
-      }
-      if (di1 == NULL) {
-        di1 = dictitem_copy(HI2DI(hi2));
-        if (dict_add(d1, di1) == FAIL) {
-          dictitem_free(di1);
-        }
-
-        if (watched) {
-          dictwatcher_notify(d1, (char *)di1->di_key, &di1->di_tv, NULL);
-        }
-      } else if (*action == 'e') {
-        EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);
-        break;
-      } else if (*action == 'f' && HI2DI(hi2) != di1) {
-        typval_T oldtv;
-
-        if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
-            || var_check_ro(di1->di_flags, arg_errmsg, arg_errmsg_len)) {
-          break;
-        }
-
-        if (watched) {
-          copy_tv(&di1->di_tv, &oldtv);
-        }
-
-        tv_clear(&di1->di_tv);
-        copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);
-
-        if (watched) {
-          dictwatcher_notify(d1, (char *)di1->di_key, &di1->di_tv, &oldtv);
-          tv_clear(&oldtv);
-        }
-      }
-    }
-  }
-}
-
-/*
  * "extend(list, list [, idx])" function
  * "extend(dict, dict [, action])" function
  */
@@ -8880,37 +8299,41 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   } else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type ==
              VAR_DICT) {
-    dict_T  *d1, *d2;
-    char_u  *action;
-    int i;
+    dict_T *d1;
+    dict_T *d2;
 
     d1 = argvars[0].vval.v_dict;
     d2 = argvars[1].vval.v_dict;
     if (d1 != NULL && !tv_check_lock(d1->dv_lock, arg_errmsg, arg_errmsg_len)
         && d2 != NULL) {
-      /* Check the third argument. */
+      const char *action = "force";
+      // Check the third argument.
       if (argvars[2].v_type != VAR_UNKNOWN) {
-        static char *(av[]) = {"keep", "force", "error"};
+        const char *const av[] = { "keep", "force", "error" };
 
-        action = get_tv_string_chk(&argvars[2]);
-        if (action == NULL)
-          return;                       /* type error; errmsg already given */
-        for (i = 0; i < 3; ++i)
-          if (STRCMP(action, av[i]) == 0)
+        action = (const char *)get_tv_string_chk(&argvars[2]);
+        if (action == NULL) {
+          return;  // Type error; error message already given.
+        }
+        size_t i;
+        for (i = 0; i < ARRAY_SIZE(av); i++) {
+          if (strcmp(action, av[i]) == 0) {
             break;
+          }
+        }
         if (i == 3) {
           EMSG2(_(e_invarg2), action);
           return;
         }
-      } else
-        action = (char_u *)"force";
+      }
 
-      dict_extend(d1, d2, action);
+      tv_dict_extend(d1, d2, action);
 
       copy_tv(&argvars[0], rettv);
     }
-  } else
+  } else {
     EMSG2(_(e_listdictarg), "extend()");
+  }
 }
 
 /*
@@ -9076,7 +8499,7 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
         if (!HASHITEM_EMPTY(hi)) {
           --todo;
 
-          di = HI2DI(hi);
+          di = TV_DICT_HI2DI(hi);
           if (map
               && (tv_check_lock(di->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
                   || var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len))) {
@@ -9094,7 +8517,7 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
                 || var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) {
               break;
             }
-            dictitem_remove(d, di);
+            tv_dict_item_remove(d, di);
           }
         }
       }
@@ -9639,9 +9062,10 @@ static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   } else if (argvars[0].v_type == VAR_DICT) {
     if ((d = argvars[0].vval.v_dict) != NULL) {
-      di = dict_find(d, get_tv_string(&argvars[1]), -1);
-      if (di != NULL)
+      di = tv_dict_find(d, (const char *)get_tv_string(&argvars[1]), -1);
+      if (di != NULL) {
         tv = &di->di_tv;
+      }
     }
   } else if (argvars[0].v_type == VAR_PARTIAL
              || argvars[0].v_type == VAR_FUNC) {
@@ -9704,7 +9128,7 @@ static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void get_buffer_signs(buf_T *buf, list_T *l)
 {
   for (signlist_T *sign = buf->b_signlist; sign; sign = sign->next) {
-    dict_T *const d = dict_alloc();
+    dict_T *const d = tv_dict_alloc();
 
     dict_add_nr_str(d, "id", sign->id, NULL);
     dict_add_nr_str(d, "lnum", sign->lnum, NULL);
@@ -9717,7 +9141,7 @@ static void get_buffer_signs(buf_T *buf, list_T *l)
 /// Returns buffer options, variables and other attributes in a dictionary.
 static dict_T *get_buffer_info(buf_T *buf)
 {
-  dict_T *dict = dict_alloc();
+  dict_T *const dict = tv_dict_alloc();
 
   dict_add_nr_str(dict, "bufnr", buf->b_fnum, NULL);
   dict_add_nr_str(dict, "name", 0L,
@@ -9772,12 +9196,12 @@ static void f_getbufinfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
       filtered = true;
 
-      di = dict_find(sel_d, (char_u *)"buflisted", -1);
+      di = tv_dict_find(sel_d, S_LEN("buflisted"));
       if (di != NULL && get_tv_number(&di->di_tv)) {
         sel_buflisted = true;
       }
 
-      di = dict_find(sel_d, (char_u *)"bufloaded", -1);
+      di = tv_dict_find(sel_d, S_LEN("bufloaded"));
       if (di != NULL && get_tv_number(&di->di_tv)) {
         sel_bufloaded = true;
       }
@@ -10047,7 +9471,7 @@ static void f_getcharmod(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  rettv_dict_alloc(rettv);
+  tv_dict_alloc_ret(rettv);
 
   dict_T *dict = rettv->vval.v_dict;
 
@@ -10467,7 +9891,7 @@ static void get_qf_loc_list(int is_qf, win_T *wp, typval_T *what_arg,
       (void)get_errorlist(wp, -1, rettv->vval.v_list);
     }
   } else {
-    rettv_dict_alloc(rettv);
+    tv_dict_alloc_ret(rettv);
     if (is_qf || wp != NULL) {
       if (what_arg->v_type == VAR_DICT) {
         dict_T *d = what_arg->vval.v_dict;
@@ -10499,7 +9923,7 @@ static void f_getmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   tv_list_alloc_ret(rettv);
   while (cur != NULL) {
-    dict_T *dict = dict_alloc();
+    dict_T *dict = tv_dict_alloc();
     if (cur->match.regprog == NULL) {
       // match added with matchaddpos() 
       for (i = 0; i < MAXPOSMATCH; ++i) {
@@ -10678,7 +10102,7 @@ static void f_getregtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// as a dictionary.
 static dict_T *get_tabpage_info(tabpage_T *tp, int tp_idx)
 {
-  dict_T *dict = dict_alloc();
+  dict_T *const dict = tv_dict_alloc();
 
   dict_add_nr_str(dict, "tabnr", tp_idx, NULL);
 
@@ -10776,7 +10200,7 @@ static void f_gettabwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// Returns information about a window as a dictionary.
 static dict_T *get_win_info(win_T *wp, int16_t tpnr, int16_t winnr)
 {
-  dict_T *dict = dict_alloc();
+  dict_T *const dict = tv_dict_alloc();
 
   dict_add_nr_str(dict, "tabnr", tpnr, NULL);
   dict_add_nr_str(dict, "winnr", winnr, NULL);
@@ -11286,8 +10710,9 @@ static void f_has_key(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (argvars[0].vval.v_dict == NULL)
     return;
 
-  rettv->vval.v_number = dict_find(argvars[0].vval.v_dict,
-      get_tv_string(&argvars[1]), -1) != NULL;
+  rettv->vval.v_number = tv_dict_find(argvars[0].vval.v_dict,
+                                      (const char *)get_tv_string(&argvars[1]),
+                                      -1) != NULL;
 }
 
 /// `haslocaldir([{win}[, {tab}]])` function
@@ -11912,60 +11337,48 @@ static void f_islocked(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void dict_list(typval_T *argvars, typval_T *rettv, int what)
 {
-  list_T      *l2;
-  dictitem_T  *di;
-  hashitem_T  *hi;
-  listitem_T  *li;
-  listitem_T  *li2;
-  dict_T      *d;
-  int todo;
-
   if (argvars[0].v_type != VAR_DICT) {
     EMSG(_(e_dictreq));
     return;
   }
-  if ((d = argvars[0].vval.v_dict) == NULL)
+  dict_T *const d = argvars[0].vval.v_dict;
+  if (d == NULL) {
     return;
+  }
 
   tv_list_alloc_ret(rettv);
 
-  todo = (int)d->dv_hashtab.ht_used;
-  for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi) {
-    if (!HASHITEM_EMPTY(hi)) {
-      --todo;
-      di = HI2DI(hi);
-
-      li = tv_list_item_alloc();
-      tv_list_append(rettv->vval.v_list, li);
+  TV_DICT_ITER(d, di, {
+    listitem_T *const li = tv_list_item_alloc();
+    tv_list_append(rettv->vval.v_list, li);
 
-      if (what == 0) {
-        /* keys() */
-        li->li_tv.v_type = VAR_STRING;
-        li->li_tv.v_lock = 0;
-        li->li_tv.vval.v_string = vim_strsave(di->di_key);
-      } else if (what == 1) {
-        /* values() */
-        copy_tv(&di->di_tv, &li->li_tv);
-      } else {
-        // items()
-        l2 = tv_list_alloc();
-        li->li_tv.v_type = VAR_LIST;
-        li->li_tv.v_lock = 0;
-        li->li_tv.vval.v_list = l2;
-        ++l2->lv_refcount;
+    if (what == 0) {
+      // keys()
+      li->li_tv.v_type = VAR_STRING;
+      li->li_tv.v_lock = 0;
+      li->li_tv.vval.v_string = vim_strsave(di->di_key);
+    } else if (what == 1) {
+      // values()
+      copy_tv(&di->di_tv, &li->li_tv);
+    } else {
+      // items()
+      list_T *const l2 = tv_list_alloc();
+      li->li_tv.v_type = VAR_LIST;
+      li->li_tv.v_lock = 0;
+      li->li_tv.vval.v_list = l2;
+      l2->lv_refcount++;
 
-        li2 = tv_list_item_alloc();
-        tv_list_append(l2, li2);
-        li2->li_tv.v_type = VAR_STRING;
-        li2->li_tv.v_lock = 0;
-        li2->li_tv.vval.v_string = vim_strsave(di->di_key);
+      listitem_T *sub_li = tv_list_item_alloc();
+      tv_list_append(l2, sub_li);
+      sub_li->li_tv.v_type = VAR_STRING;
+      sub_li->li_tv.v_lock = 0;
+      sub_li->li_tv.vval.v_string = vim_strsave(di->di_key);
 
-        li2 = tv_list_item_alloc();
-        tv_list_append(l2, li2);
-        copy_tv(&di->di_tv, &li2->li_tv);
-      }
+      sub_li = tv_list_item_alloc();
+      tv_list_append(l2, sub_li);
+      copy_tv(&di->di_tv, &sub_li->li_tv);
     }
-  }
+  });
 }
 
 /// "id()" function
@@ -12230,23 +11643,26 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 
   dict_T *job_opts = NULL;
-  bool detach = false, rpc = false, pty = false;
-  Callback on_stdout = CALLBACK_NONE, on_stderr = CALLBACK_NONE,
-           on_exit = CALLBACK_NONE;
+  bool detach = false;
+  bool rpc = false;
+  bool pty = false;
+  Callback on_stdout = CALLBACK_NONE;
+  Callback on_stderr = CALLBACK_NONE;
+  Callback on_exit = CALLBACK_NONE;
   char *cwd = NULL;
   if (argvars[1].v_type == VAR_DICT) {
     job_opts = argvars[1].vval.v_dict;
 
-    detach = get_dict_number(job_opts, "detach") != 0;
-    rpc = get_dict_number(job_opts, "rpc") != 0;
-    pty = get_dict_number(job_opts, "pty") != 0;
+    detach = tv_dict_get_number(job_opts, "detach") != 0;
+    rpc = tv_dict_get_number(job_opts, "rpc") != 0;
+    pty = tv_dict_get_number(job_opts, "pty") != 0;
     if (pty && rpc) {
       EMSG2(_(e_invarg2), "job cannot have both 'pty' and 'rpc' options set");
       shell_free_argv(argv);
       return;
     }
 
-    char *new_cwd = (char *)get_dict_string(job_opts, "cwd", false);
+    char *new_cwd = tv_dict_get_string(job_opts, "cwd", false);
     if (new_cwd && strlen(new_cwd) > 0) {
       cwd = new_cwd;
       // The new cwd must be a directory.
@@ -12268,15 +11684,15 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   Process *proc = (Process *)&data->proc;
 
   if (pty) {
-    uint16_t width = get_dict_number(job_opts, "width");
+    uint16_t width = (uint16_t)tv_dict_get_number(job_opts, "width");
     if (width > 0) {
       data->proc.pty.width = width;
     }
-    uint16_t height = get_dict_number(job_opts, "height");
+    uint16_t height = (uint16_t)tv_dict_get_number(job_opts, "height");
     if (height > 0) {
       data->proc.pty.height = height;
     }
-    char *term = (char *)get_dict_string(job_opts, "TERM", true);
+    char *term = tv_dict_get_string(job_opts, "TERM", true);
     if (term) {
       data->proc.pty.term_name = term;
     }
@@ -12537,7 +11953,7 @@ static void f_len(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     rettv->vval.v_number = tv_list_len(argvars[0].vval.v_list);
     break;
   case VAR_DICT:
-    rettv->vval.v_number = dict_len(argvars[0].vval.v_dict);
+    rettv->vval.v_number = tv_dict_len(argvars[0].vval.v_dict);
     break;
   case VAR_UNKNOWN:
   case VAR_SPECIAL:
@@ -12714,7 +12130,7 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
       rettv->vval.v_string = str2special_save(rhs, FALSE);
 
   } else {
-    rettv_dict_alloc(rettv);
+    tv_dict_alloc_ret(rettv);
     if (rhs != NULL) {
       // Return a dictionary.
       char_u *lhs = str2special_save(mp->m_keys, true);
@@ -12980,10 +12396,10 @@ static void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
           EMSG(_(e_dictreq));
           return;
         }
-        if (dict_find(argvars[4].vval.v_dict,
-                      (char_u *)"conceal", -1) != NULL) {
-          conceal_char = get_dict_string(argvars[4].vval.v_dict,
-                                         "conceal", false);
+        dictitem_T *di;
+        if ((di = tv_dict_find(argvars[4].vval.v_dict, S_LEN("conceal")))
+            != NULL) {
+          conceal_char = get_tv_string(&di->di_tv);
         }
       }
     }
@@ -12996,8 +12412,9 @@ static void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     return;
   }
 
-  rettv->vval.v_number = match_add(curwin, grp, pat, prio, id, NULL,
-                                   conceal_char);
+  rettv->vval.v_number = match_add(curwin, (const char *)grp,
+                                   (const char *)pat, prio, id,
+                                   NULL, (const char *)conceal_char);
 }
 
 static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
@@ -13005,8 +12422,7 @@ static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     rettv->vval.v_number = -1;
     
     char_u buf[NUMBUFLEN];
-    char_u *group;
-    group = get_tv_string_buf_chk(&argvars[0], buf);
+    const char_u *const group = get_tv_string_buf_chk(&argvars[0], buf);
     if (group == NULL) {
         return;
     }
@@ -13036,10 +12452,10 @@ static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
             EMSG(_(e_dictreq));
             return;
           }
-          if (dict_find(argvars[4].vval.v_dict,
-                        (char_u *)"conceal", -1) != NULL) {
-            conceal_char = get_dict_string(argvars[4].vval.v_dict,
-                                           "conceal", false);
+          dictitem_T *di;
+          if ((di = tv_dict_find(argvars[4].vval.v_dict, S_LEN("conceal")))
+              != NULL) {
+            conceal_char = get_tv_string(&di->di_tv);
           }
         }
       }
@@ -13054,8 +12470,8 @@ static void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         return;
     }
 
-  rettv->vval.v_number = match_add(curwin, group, NULL, prio, id, l,
-                                   conceal_char);
+  rettv->vval.v_number = match_add(curwin, (const char *)group, NULL, prio, id,
+                                   l, (const char *)conceal_char);
 }
 
 /*
@@ -13156,8 +12572,8 @@ static void max_min(typval_T *argvars, typval_T *rettv, int domax)
       todo = (int)d->dv_hashtab.ht_used;
       for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi) {
         if (!HASHITEM_EMPTY(hi)) {
-          --todo;
-          i = get_tv_number_chk(&HI2DI(hi)->di_tv, &error);
+          todo--;
+          i = get_tv_number_chk(&TV_DICT_HI2DI(hi)->di_tv, &error);
           if (first) {
             n = i;
             first = FALSE;
@@ -13845,7 +13261,6 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   listitem_T  *li;
   long idx;
   long end;
-  char_u      *key;
   dict_T      *d;
   dictitem_T  *di;
   const char *const arg_errmsg = _("remove() argument");
@@ -13856,18 +13271,18 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       EMSG2(_(e_toomanyarg), "remove()");
     } else if ((d = argvars[0].vval.v_dict) != NULL
                && !tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len)) {
-      key = get_tv_string_chk(&argvars[1]);
+      const char *key = (const char *)get_tv_string_chk(&argvars[1]);
       if (key != NULL) {
-        di = dict_find(d, key, -1);
+        di = tv_dict_find(d, key, -1);
         if (di == NULL) {
           EMSG2(_(e_dictkey), key);
         } else if (!var_check_fixed(di->di_flags, arg_errmsg, arg_errmsg_len)
                    && !var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) {
           *rettv = di->di_tv;
-          init_tv(&di->di_tv);
-          dictitem_remove(d, di);
-          if (is_watched(d)) {
-            dictwatcher_notify(d, (char *)key, NULL, rettv);
+          di->di_tv = TV_INITIAL_VALUE;
+          tv_dict_item_remove(d, di);
+          if (tv_dict_is_watched(d)) {
+            tv_dict_watcher_notify(d, key, NULL, rettv);
           }
         }
       }
@@ -14967,7 +14382,6 @@ static void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (buf != NULL && varname != NULL && varp != NULL) {
     if (*varname == '&') {
       long numval;
-      char_u *strval;
       bool error = false;
       aco_save_T aco;
 
@@ -14976,9 +14390,9 @@ static void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
       varname++;
       numval = get_tv_number_chk(varp, &error);
-      strval = get_tv_string_buf_chk(varp, nbuf);
+      char *const strval = (char *)get_tv_string_buf_chk(varp, nbuf);
       if (!error && strval != NULL) {
-        set_option_value((char_u *)varname, numval, strval, OPT_LOCAL);
+        set_option_value(varname, numval, strval, OPT_LOCAL);
       }
 
       // reset notion of buffer
@@ -14987,7 +14401,7 @@ static void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       buf_T *save_curbuf = curbuf;
 
       const size_t varname_len = STRLEN(varname);
-      char_u *const bufvarname = xmalloc(STRLEN(varname) + 3);
+      char *const bufvarname = xmalloc(varname_len + 3);
       curbuf = buf;
       memcpy(bufvarname, "b:", 2);
       memcpy(bufvarname + 2, varname, varname_len + 1);
@@ -15002,7 +14416,6 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   dict_T        *d;
   dictitem_T        *di;
-  char_u        *csearch;
 
   if (argvars[0].v_type != VAR_DICT) {
     EMSG(_(e_dictreq));
@@ -15010,7 +14423,7 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   if ((d = argvars[0].vval.v_dict) != NULL) {
-    csearch = get_dict_string(d, "char", false);
+    char_u *const csearch = (char_u *)tv_dict_get_string(d, "char", false);
     if (csearch != NULL) {
       if (enc_utf8) {
         int pcc[MAX_MCO];
@@ -15022,13 +14435,15 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
                          csearch, MB_PTR2LEN(csearch));
     }
 
-    di = dict_find(d, (char_u *)"forward", -1);
-    if (di != NULL)
+    di = tv_dict_find(d, S_LEN("forward"));
+    if (di != NULL) {
       set_csearch_direction(get_tv_number(&di->di_tv) ? FORWARD : BACKWARD);
+    }
 
-    di = dict_find(d, (char_u *)"until", -1);
-    if (di != NULL)
+    di = tv_dict_find(d, S_LEN("until"));
+    if (di != NULL) {
       set_csearch_until(!!get_tv_number(&di->di_tv));
+    }
   }
 }
 
@@ -15252,11 +14667,11 @@ static void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         EMSG(_(e_invarg));
         return;
       }
-      if (!(dict_find(d, (char_u *)"group", -1) != NULL
-            && (dict_find(d, (char_u *)"pattern", -1) != NULL
-                || dict_find(d, (char_u *)"pos1", -1) != NULL)
-            && dict_find(d, (char_u *)"priority", -1) != NULL
-            && dict_find(d, (char_u *)"id", -1) != NULL)) {
+      if (!(tv_dict_find(d, S_LEN("group")) != NULL
+            && (tv_dict_find(d, S_LEN("pattern")) != NULL
+                || tv_dict_find(d, S_LEN("pos1")) != NULL)
+            && tv_dict_find(d, S_LEN("priority")) != NULL
+            && tv_dict_find(d, S_LEN("id")) != NULL)) {
         EMSG(_(e_invarg));
         return;
       }
@@ -15267,11 +14682,10 @@ static void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     li = l->lv_first;
     while (li != NULL) {
       int i = 0;
-      char_u buf[5];
-      dictitem_T *di;
 
       d = li->li_tv.vval.v_dict;
-      if (dict_find(d, (char_u *)"pattern", -1) == NULL) {
+      dictitem_T *const di = tv_dict_find(d, S_LEN("pattern"));
+      if (di == NULL) {
         if (s == NULL) {
           s = tv_list_alloc();
           if (s == NULL) {
@@ -15280,14 +14694,16 @@ static void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         }
 
         // match from matchaddpos()
-        for (i = 1; i < 9; ++i) {
-          snprintf((char *)buf, sizeof(buf), (char *)"pos%d", i);
-          if ((di = dict_find(d, (char_u *)buf, -1)) != NULL) {
-            if (di->di_tv.v_type != VAR_LIST) {
+        for (i = 1; i < 9; i++) {
+          char buf[5];
+          snprintf(buf, sizeof(buf), "pos%d", i);
+          dictitem_T *const pos_di = tv_dict_find(d, buf, -1);
+          if (pos_di != NULL) {
+            if (pos_di->di_tv.v_type != VAR_LIST) {
               return;
             }
 
-            tv_list_append_tv(s, &di->di_tv);
+            tv_list_append_tv(s, &pos_di->di_tv);
             s->lv_refcount++;
           } else {
             break;
@@ -15295,23 +14711,31 @@ static void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
         }
       }
 
-      char_u *group = get_dict_string(d, "group", true);
-      int priority = get_dict_number(d, "priority");
-      int id = get_dict_number(d, "id");
-      char_u *conceal = dict_find(d, (char_u *)"conceal", -1) != NULL
-                                  ? get_dict_string(d, "conceal", true)
-                                  : NULL;
+      // Note: there are three number buffers involved:
+      // - group_buf below.
+      // - numbuf in tv_dict_get_string().
+      // - mybuf in get_tv_string().
+      //
+      // If you change this code make sure that buffers will not get
+      // accidentally reused.
+      char group_buf[NUMBUFLEN];
+      const char *const group = tv_dict_get_string_buf(d, "group", group_buf);
+      const int priority = (int)tv_dict_get_number(d, "priority");
+      const int id = (int)tv_dict_get_number(d, "id");
+      dictitem_T *const conceal_di = tv_dict_find(d, S_LEN("conceal"));
+      const char *const conceal = (conceal_di != NULL
+                                   ? (const char *)get_tv_string(
+                                       &conceal_di->di_tv)
+                                   : NULL);
       if (i == 0) {
         match_add(curwin, group,
-                  get_dict_string(d, "pattern", false),
+                  tv_dict_get_string(d, "pattern", false),
                   priority, id, NULL, conceal);
       } else {
         match_add(curwin, group, NULL, priority, id, s, conceal);
         tv_list_unref(s);
         s = NULL;
       }
-      xfree(group);
-      xfree(conceal);
       li = li->li_next;
     }
     rettv->vval.v_number = 0;
@@ -15471,35 +14895,31 @@ free_lstval:
  */
 static void f_settabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  tabpage_T   *save_curtab;
-  tabpage_T   *tp;
-  char_u      *varname, *tabvarname;
-  typval_T    *varp;
-
   rettv->vval.v_number = 0;
 
-  if (check_restricted() || check_secure())
+  if (check_restricted() || check_secure()) {
     return;
+  }
 
-  tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL));
-  varname = get_tv_string_chk(&argvars[1]);
-  varp = &argvars[2];
-
-  if (varname != NULL && varp != NULL
-      && tp != NULL
-      ) {
-    save_curtab = curtab;
-    goto_tabpage_tp(tp, FALSE, FALSE);
-
-    tabvarname = xmalloc(STRLEN(varname) + 3);
-    STRCPY(tabvarname, "t:");
-    STRCPY(tabvarname + 2, varname);
-    set_var(tabvarname, varp, TRUE);
+  tabpage_T *const tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL));
+  const char *const varname = (const char *)get_tv_string_chk(&argvars[1]);
+  typval_T *const varp = &argvars[2];
+
+  if (varname != NULL && varp != NULL && tp != NULL) {
+    tabpage_T *const save_curtab = curtab;
+    goto_tabpage_tp(tp, false, false);
+
+    const size_t varname_len = strlen(varname);
+    char *const tabvarname = xmalloc(varname_len + 3);
+    memcpy(tabvarname, "t:", 2);
+    memcpy(tabvarname + 2, varname, varname_len + 1);
+    set_var(tabvarname, varp, true);
     xfree(tabvarname);
 
-    /* Restore current tabpage */
-    if (valid_tabpage(save_curtab))
-      goto_tabpage_tp(save_curtab, FALSE, FALSE);
+    // Restore current tabpage.
+    if (valid_tabpage(save_curtab)) {
+      goto_tabpage_tp(save_curtab, false, false);
+    }
   }
 }
 
@@ -15525,44 +14945,42 @@ static void f_setwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void setwinvar(typval_T *argvars, typval_T *rettv, int off)
 {
-  win_T       *win;
-  win_T       *save_curwin;
-  tabpage_T   *save_curtab;
-  char_u      *varname, *winvarname;
-  typval_T    *varp;
-  char_u nbuf[NUMBUFLEN];
-  tabpage_T   *tp = NULL;
-
-  if (check_restricted() || check_secure())
+  if (check_restricted() || check_secure()) {
     return;
+  }
 
-  if (off == 1)
+  tabpage_T *tp = NULL;
+  if (off == 1) {
     tp = find_tabpage((int)get_tv_number_chk(&argvars[0], NULL));
-  else
+  } else {
     tp = curtab;
-  win = find_win_by_nr(&argvars[off], tp);
-  varname = get_tv_string_chk(&argvars[off + 1]);
-  varp = &argvars[off + 2];
+  }
+  win_T *const win = find_win_by_nr(&argvars[off], tp);
+  const char *varname = (const char *)get_tv_string_chk(&argvars[off + 1]);
+  typval_T *varp = &argvars[off + 2];
 
   if (win != NULL && varname != NULL && varp != NULL) {
+    win_T       *save_curwin;
+    tabpage_T   *save_curtab;
     bool need_switch_win = tp != curtab || win != curwin;
     if (!need_switch_win
         || switch_win(&save_curwin, &save_curtab, win, tp, true) == OK) {
       if (*varname == '&') {
         long numval;
-        char_u *strval;
         bool error = false;
 
-        ++varname;
+        varname++;
         numval = get_tv_number_chk(varp, &error);
-        strval = get_tv_string_buf_chk(varp, nbuf);
+        char_u nbuf[NUMBUFLEN];
+        char *const strval = (char *)get_tv_string_buf_chk(varp, nbuf);
         if (!error && strval != NULL) {
           set_option_value(varname, numval, strval, OPT_LOCAL);
         }
       } else {
-        winvarname = xmalloc(STRLEN(varname) + 3);
-        STRCPY(winvarname, "w:");
-        STRCPY(winvarname + 2, varname);
+        const size_t varname_len = strlen(varname);
+        char *const winvarname = xmalloc(varname_len + 3);
+        memcpy(winvarname, "w:", 2);
+        memcpy(winvarname + 2, varname, varname_len + 1);
         set_var(winvarname, varp, true);
         xfree(winvarname);
       }
@@ -17086,15 +16504,15 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   Callback on_stdout = CALLBACK_NONE, on_stderr = CALLBACK_NONE,
            on_exit = CALLBACK_NONE;
   dict_T *job_opts = NULL;
-  char *cwd = ".";
+  const char *cwd = ".";
   if (argvars[1].v_type == VAR_DICT) {
     job_opts = argvars[1].vval.v_dict;
 
-    char *new_cwd = (char *)get_dict_string(job_opts, "cwd", false);
-    if (new_cwd && strlen(new_cwd) > 0) {
+    const char *const new_cwd = tv_dict_get_string(job_opts, "cwd", false);
+    if (new_cwd && *new_cwd != NUL) {
       cwd = new_cwd;
       // The new cwd must be a directory.
-      if (!os_isdir((char_u *)cwd)) {
+      if (!os_isdir((const char_u *)cwd)) {
         EMSG2(_(e_invarg2), "expected valid directory");
         shell_free_argv(argv);
         return;
@@ -17131,7 +16549,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   // at this point the buffer has no terminal instance associated yet, so unset
   // the 'swapfile' option to ensure no swap file will be created
   curbuf->b_p_swf = false;
-  (void)setfname(curbuf, (uint8_t *)buf, NULL, true);
+  (void)setfname(curbuf, (char_u *)buf, NULL, true);
   // Save the job id and pid in b:terminal_job_{id,pid}
   Error err;
   dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_id"),
@@ -17177,23 +16595,25 @@ static bool callback_from_typval(Callback *callback, typval_T *arg)
 
 
 /// Unref/free callback
-static void callback_free(Callback *callback)
+void callback_free(Callback *const callback)
+  FUNC_ATTR_NONNULL_ALL
 {
   switch (callback->type) {
-    case kCallbackFuncref:
+    case kCallbackFuncref: {
       func_unref(callback->data.funcref);
       xfree(callback->data.funcref);
       break;
-
-    case kCallbackPartial:
+    }
+    case kCallbackPartial: {
       partial_unref(callback->data.partial);
       break;
-
-    case kCallbackNone:
+    }
+    case kCallbackNone: {
       break;
-
-    default:
+    }
+    default: {
       abort();
+    }
   }
   callback->type = kCallbackNone;
 }
@@ -17220,8 +16640,9 @@ static bool callback_equal(Callback *cb1, Callback *cb2)
   }
 }
 
-static bool callback_call(Callback *callback, int argcount_in,
-                          typval_T *argvars_in, typval_T *rettv)
+bool callback_call(Callback *const callback, const int argcount_in,
+                   typval_T *const argvars_in, typval_T *const rettv)
+  FUNC_ATTR_NONNULL_ALL
 {
   partial_T *partial;
   char_u *name;
@@ -17290,8 +16711,9 @@ static void f_timer_start(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       EMSG2(_(e_invarg2), get_tv_string(&argvars[2]));
       return;
     }
-    if (dict_find(dict, (char_u *)"repeat", -1) != NULL) {
-      repeat = get_dict_number(dict, "repeat");
+    dictitem_T *const di = tv_dict_find(dict, S_LEN("repeat"));
+    if (di != NULL) {
+      repeat = get_tv_number(&di->di_tv);
       if (repeat == 0) {
         repeat = 1;
       }
@@ -17353,13 +16775,11 @@ static void timer_due_cb(TimeWatcher *tw, void *data)
     timer_stop(timer);
   }
 
-  typval_T argv[2];
-  init_tv(argv);
+  typval_T argv[2] = { TV_INITIAL_VALUE, TV_INITIAL_VALUE };
   argv[0].v_type = VAR_NUMBER;
   argv[0].vval.v_number = timer->timer_id;
-  typval_T rettv;
+  typval_T rettv = TV_INITIAL_VALUE;
 
-  init_tv(&rettv);
   callback_call(&timer->callback, 1, argv, &rettv);
   tv_clear(&rettv);
 
@@ -17614,7 +17034,7 @@ static void f_undofile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_undotree(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  rettv_dict_alloc(rettv);
+  tv_dict_alloc_ret(rettv);
 
   dict_T *dict = rettv->vval.v_dict;
   list_T *list;
@@ -17802,36 +17222,37 @@ static void f_winrestcmd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_winrestview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  dict_T      *dict;
+  dict_T *dict;
 
   if (argvars[0].v_type != VAR_DICT
-      || (dict = argvars[0].vval.v_dict) == NULL)
-    EMSG(_(e_invarg));
-  else {
-    if (dict_find(dict, (char_u *)"lnum", -1) != NULL) {
-      curwin->w_cursor.lnum = get_dict_number(dict, "lnum");
+      || (dict = argvars[0].vval.v_dict) == NULL) {
+    emsgf(_(e_invarg));
+  } else {
+    dictitem_T *di;
+    if ((di = tv_dict_find(dict, S_LEN("lnum"))) != NULL) {
+      curwin->w_cursor.lnum = get_tv_number(&di->di_tv);
     }
-    if (dict_find(dict, (char_u *)"col", -1) != NULL) {
-      curwin->w_cursor.col = get_dict_number(dict, "col");
+    if ((di = tv_dict_find(dict, S_LEN("col"))) != NULL) {
+      curwin->w_cursor.col = get_tv_number(&di->di_tv);
     }
-    if (dict_find(dict, (char_u *)"coladd", -1) != NULL) {
-      curwin->w_cursor.coladd = get_dict_number(dict, "coladd");
+    if ((di = tv_dict_find(dict, S_LEN("coladd"))) != NULL) {
+      curwin->w_cursor.coladd = get_tv_number(&di->di_tv);
     }
-    if (dict_find(dict, (char_u *)"curswant", -1) != NULL) {
-      curwin->w_curswant = get_dict_number(dict, "curswant");
+    if ((di = tv_dict_find(dict, S_LEN("curswant"))) != NULL) {
+      curwin->w_curswant = get_tv_number(&di->di_tv);
       curwin->w_set_curswant = false;
     }
-    if (dict_find(dict, (char_u *)"topline", -1) != NULL) {
-      set_topline(curwin, get_dict_number(dict, "topline"));
+    if ((di = tv_dict_find(dict, S_LEN("topline"))) != NULL) {
+      set_topline(curwin, get_tv_number(&di->di_tv));
     }
-    if (dict_find(dict, (char_u *)"topfill", -1) != NULL) {
-      curwin->w_topfill = get_dict_number(dict, "topfill");
+    if ((di = tv_dict_find(dict, S_LEN("topfill"))) != NULL) {
+      curwin->w_topfill = get_tv_number(&di->di_tv);
     }
-    if (dict_find(dict, (char_u *)"leftcol", -1) != NULL) {
-      curwin->w_leftcol = get_dict_number(dict, "leftcol");
+    if ((di = tv_dict_find(dict, S_LEN("leftcol"))) != NULL) {
+      curwin->w_leftcol = get_tv_number(&di->di_tv);
     }
-    if (dict_find(dict, (char_u *)"skipcol", -1) != NULL) {
-      curwin->w_skipcol = get_dict_number(dict, "skipcol");
+    if ((di = tv_dict_find(dict, S_LEN("skipcol"))) != NULL) {
+      curwin->w_skipcol = get_tv_number(&di->di_tv);
     }
 
     check_cursor();
@@ -17854,7 +17275,7 @@ static void f_winsaveview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   dict_T      *dict;
 
-  rettv_dict_alloc(rettv);
+  tv_dict_alloc_ret(rettv);
   dict = rettv->vval.v_dict;
 
   dict_add_nr_str(dict, "lnum", (long)curwin->w_cursor.lnum, NULL);
@@ -18027,7 +17448,7 @@ static void f_winwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "wordcount()" function
 static void f_wordcount(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  rettv_dict_alloc(rettv);
+  tv_dict_alloc_ret(rettv);
   cursor_pos_info(rettv->vval.v_dict);
 }
 
@@ -18895,10 +18316,10 @@ handle_subscript(
         }
         ret = FAIL;
       }
-      dict_unref(selfdict);
+      tv_dict_unref(selfdict);
       selfdict = NULL;
-    } else { /* **arg == '[' || **arg == '.' */
-      dict_unref(selfdict);
+    } else {  // **arg == '[' || **arg == '.'
+      tv_dict_unref(selfdict);
       if (rettv->v_type == VAR_DICT) {
         selfdict = rettv->vval.v_dict;
         if (selfdict != NULL)
@@ -18919,7 +18340,7 @@ handle_subscript(
     set_selfdict(rettv, selfdict);
   }
 
-  dict_unref(selfdict);
+  tv_dict_unref(selfdict);
   return ret;
 }
 
@@ -19016,7 +18437,7 @@ void free_tv(typval_T *varp)
         tv_list_unref(varp->vval.v_list);
         break;
       case VAR_DICT:
-        dict_unref(varp->vval.v_dict);
+        tv_dict_unref(varp->vval.v_dict);
         break;
       case VAR_SPECIAL:
       case VAR_NUMBER:
@@ -19028,15 +18449,6 @@ void free_tv(typval_T *varp)
   }
 }
 
-/*
- * Set the value of a variable to NULL without freeing items.
- */
-static void init_tv(typval_T *varp)
-{
-  if (varp != NULL)
-    memset(varp, 0, sizeof(typval_T));
-}
-
 // TODO(ZyX-I): move to eval/typval
 
 /// Get the number value of a variable
@@ -19057,44 +18469,53 @@ varnumber_T get_tv_number(const typval_T *const varp)
 
 varnumber_T get_tv_number_chk(const typval_T *const varp, bool *const denote)
 {
-  long n = 0L;
+  varnumber_T n = 0;
 
   switch (varp->v_type) {
-  case VAR_NUMBER:
-    return (long)(varp->vval.v_number);
-  case VAR_FLOAT:
-    EMSG(_("E805: Using a Float as a Number"));
-    break;
-  case VAR_FUNC:
-  case VAR_PARTIAL:
-    EMSG(_("E703: Using a Funcref as a Number"));
-    break;
-  case VAR_STRING:
-    if (varp->vval.v_string != NULL) {
-      vim_str2nr(varp->vval.v_string, NULL, NULL,
-                 STR2NR_ALL, &n, NULL, 0);
+    case VAR_NUMBER: {
+      return varp->vval.v_number;
     }
-    return n;
-  case VAR_LIST:
-    EMSG(_("E745: Using a List as a Number"));
-    break;
-  case VAR_DICT:
-    EMSG(_("E728: Using a Dictionary as a Number"));
-    break;
-  case VAR_SPECIAL:
-    switch (varp->vval.v_special) {
-      case kSpecialVarTrue: {
-        return 1;
+    case VAR_FLOAT: {
+      EMSG(_("E805: Using a Float as a Number"));
+      break;
+    }
+    case VAR_PARTIAL:
+    case VAR_FUNC: {
+      EMSG(_("E703: Using a Funcref as a Number"));
+      break;
+    }
+    case VAR_STRING: {
+      if (varp->vval.v_string != NULL) {
+        long nr;
+        vim_str2nr(varp->vval.v_string, NULL, NULL, STR2NR_ALL, &nr, NULL, 0);
+        n = (varnumber_T)nr;
       }
-      case kSpecialVarFalse:
-      case kSpecialVarNull: {
-        return 0;
+      return n;
+    }
+    case VAR_LIST: {
+      EMSG(_("E745: Using a List as a Number"));
+      break;
+    }
+    case VAR_DICT: {
+      EMSG(_("E728: Using a Dictionary as a Number"));
+      break;
+    }
+    case VAR_SPECIAL: {
+      switch (varp->vval.v_special) {
+        case kSpecialVarTrue: {
+          return 1;
+        }
+        case kSpecialVarFalse:
+        case kSpecialVarNull: {
+          return 0;
+        }
       }
+      break;
+    }
+    case VAR_UNKNOWN: {
+      EMSG2(_(e_intern2), "get_tv_number(UNKNOWN)");
+      break;
     }
-    break;
-  case VAR_UNKNOWN:
-    EMSG2(_(e_intern2), "get_tv_number(UNKNOWN)");
-    break;
   }
   if (denote == NULL) {
     // useful for values that must be unsigned
@@ -19254,16 +18675,17 @@ static dictitem_T *find_var(const char *const name, const size_t name_len,
                             hashtab_T **htp, int no_autoload)
 {
   const char *varname;
-  hashtab_T   *ht = find_var_ht(name, name_len, &varname);
+  hashtab_T *const ht = find_var_ht(name, name_len, &varname);
   if (htp != NULL) {
     *htp = ht;
   }
   if (ht == NULL) {
     return NULL;
   }
-  dictitem_T *ret = find_var_in_ht(ht, *name,
-                                   varname, name_len - (size_t)(varname - name),
-                                   no_autoload || htp != NULL);
+  dictitem_T *const ret = find_var_in_ht(ht, *name,
+                                         varname,
+                                         name_len - (size_t)(varname - name),
+                                         no_autoload || htp != NULL);
   if (ret != NULL) {
     return ret;
   }
@@ -19327,7 +18749,7 @@ static dictitem_T *find_var_in_ht(hashtab_T *const ht,
       return NULL;
     }
   }
-  return HI2DI(hi);
+  return TV_DICT_HI2DI(hi);
 }
 
 // Get function call environment based on backtrace debug level
@@ -19528,7 +18950,7 @@ void unref_var_dict(dict_T *dict)
   /* Now the dict needs to be freed if no one else is using it, go back to
    * normal reference counting. */
   dict->dv_refcount -= DO_NOT_FREE_CNT - 1;
-  dict_unref(dict);
+  tv_dict_unref(dict);
 }
 
 /*
@@ -19559,7 +18981,7 @@ static void vars_clear_ext(hashtab_T *ht, int free_val)
       // Free the variable.  Don't remove it from the hashtab,
       // ht_array might change then.  hash_clear() takes care of it
       // later.
-      v = HI2DI(hi);
+      v = TV_DICT_HI2DI(hi);
       if (free_val) {
         tv_clear(&v->di_tv);
       }
@@ -19578,7 +19000,7 @@ static void vars_clear_ext(hashtab_T *ht, int free_val)
  */
 static void delete_var(hashtab_T *ht, hashitem_T *hi)
 {
-  dictitem_T  *di = HI2DI(hi);
+  dictitem_T  *di = TV_DICT_HI2DI(hi);
 
   hash_remove(ht, hi);
   tv_clear(&di->di_tv);
@@ -19637,40 +19059,31 @@ static void list_one_var_a(const char *prefix, const char *name,
   }
 }
 
-/*
- * Set variable "name" to value in "tv".
- * If the variable already exists, the value is updated.
- * Otherwise the variable is created.
- */
-static void 
-set_var (
-    char_u *name,
-    typval_T *tv,
-    int copy                   /* make copy of value in "tv" */
-)
+/// Set variable to the given value
+///
+/// If the variable already exists, the value is updated. Otherwise the variable
+/// is created.
+///
+/// @param[in]  name  Variable name to set.
+/// @param  tv  Variable value.
+/// @param[in]  copy  True if value in tv is to be copied.
+static void set_var(const char *name, typval_T *const tv, const bool copy)
+  FUNC_ATTR_NONNULL_ALL
 {
   dictitem_T  *v;
   hashtab_T   *ht;
-  typval_T oldtv;
   dict_T *dict;
 
-  const size_t name_len = STRLEN(name);
-  char_u *varname;
-  ht = find_var_ht_dict((const char *)name, name_len, (const char **)&varname,
-                        &dict);
-  bool watched = is_watched(dict);
-
-  if (watched) {
-    init_tv(&oldtv);
-  }
+  const size_t name_len = strlen(name);
+  const char *varname;
+  ht = find_var_ht_dict(name, name_len, &varname, &dict);
+  const bool watched = tv_dict_is_watched(dict);
 
   if (ht == NULL || *varname == NUL) {
     EMSG2(_(e_illvar), name);
     return;
   }
-  v = find_var_in_ht(ht, 0,
-                     (const char *)varname, name_len - (size_t)(varname - name),
-                     true);
+  v = find_var_in_ht(ht, 0, varname, name_len - (size_t)(varname - name), true);
 
   // Search in parent scope which is possible to reference from lambda
   if (v == NULL) {
@@ -19678,10 +19091,11 @@ set_var (
   }
 
   if ((tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
-      && var_check_func_name(name, v == NULL)) {
+      && !var_check_func_name(name, v == NULL)) {
     return;
   }
 
+  typval_T oldtv = TV_INITIAL_VALUE;
   if (v != NULL) {
     // existing variable, need to clear the value
     if (var_check_ro(v->di_flags, (const char *)name, name_len)
@@ -19704,9 +19118,9 @@ set_var (
         return;
       } else if (v->di_tv.v_type == VAR_NUMBER) {
         v->di_tv.vval.v_number = get_tv_number(tv);
-        if (STRCMP(varname, "searchforward") == 0)
+        if (strcmp(varname, "searchforward") == 0) {
           set_search_direction(v->di_tv.vval.v_number ? '/' : '?');
-        else if (STRCMP(varname, "hlsearch") == 0) {
+        } else if (strcmp(varname, "hlsearch") == 0) {
           no_hlsearch = !v->di_tv.vval.v_number;
           redraw_all_later(SOME_VALID);
         }
@@ -19727,13 +19141,14 @@ set_var (
       return;
     }
 
-    /* Make sure the variable name is valid. */
-    if (!valid_varname(varname))
+    // Make sure the variable name is valid.
+    if (!valid_varname(varname)) {
       return;
+    }
 
-    v = xmalloc(sizeof(dictitem_T) + STRLEN(varname));
+    v = xmalloc(sizeof(dictitem_T) + strlen(varname));
     STRCPY(v->di_key, varname);
-    if (hash_add(ht, DI2HIKEY(v)) == FAIL) {
+    if (tv_dict_add(dict, v) == FAIL) {
       xfree(v);
       return;
     }
@@ -19745,14 +19160,14 @@ set_var (
   } else {
     v->di_tv = *tv;
     v->di_tv.v_lock = 0;
-    init_tv(tv);
+    tv_init(tv);
   }
 
   if (watched) {
     if (oldtv.v_type == VAR_UNKNOWN) {
-      dictwatcher_notify(dict, (char *)v->di_key, &v->di_tv, NULL);
+      tv_dict_watcher_notify(dict, (char *)v->di_key, &v->di_tv, NULL);
     } else {
-      dictwatcher_notify(dict, (char *)v->di_key, &v->di_tv, &oldtv);
+      tv_dict_watcher_notify(dict, (char *)v->di_key, &v->di_tv, &oldtv);
       tv_clear(&oldtv);
     }
   }
@@ -19768,8 +19183,8 @@ set_var (
 ///
 /// @return True if variable is read-only: either always or in sandbox when
 ///         sandbox is enabled, false otherwise.
-static bool var_check_ro(const int flags, const char *const name,
-                         const size_t name_len)
+bool var_check_ro(const int flags, const char *const name,
+                  const size_t name_len)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
   if (flags & DI_FLAGS_RO) {
@@ -19804,22 +19219,24 @@ static bool var_check_fixed(const int flags, const char *const name,
   return false;
 }
 
-/*
- * Check if a funcref is assigned to a valid variable name.
- * Return TRUE and give an error if not.
- */
-static int 
-var_check_func_name (
-    char_u *name,        /* points to start of variable name */
-    int new_var         /* TRUE when creating the variable */
-)
+// TODO(ZyX-I): move to eval/expressions
+
+/// Check if name is a valid name to assign funcref to
+///
+/// @param[in]  name  Possible function/funcref name.
+/// @param[in]  new_var  True if it is a name for a variable.
+///
+/// @return false in case of error, true in case of success. Also gives an
+///         error message if appropriate.
+bool var_check_func_name(const char *const name, const bool new_var)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
   // Allow for w: b: s: and t:.
   if (!(vim_strchr((char_u *)"wbst", name[0]) != NULL && name[1] == ':')
       && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':') ? name[2]
                                                            : name[0])) {
     EMSG2(_("E704: Funcref variable name must start with a capital: %s"), name);
-    return TRUE;
+    return false;
   }
   // Don't allow hiding a function.  When "v" is not NULL we might be
   // assigning another function to the same var, the type is checked
@@ -19827,63 +19244,30 @@ var_check_func_name (
   if (new_var && function_exists((const char *)name, false)) {
     EMSG2(_("E705: Variable name conflicts with existing function: %s"),
           name);
-    return true;
+    return false;
   }
-  return false;
+  return true;
 }
 
-/*
- * Check if a variable name is valid.
- * Return FALSE and give an error if not.
- */
-static int valid_varname(char_u *varname)
-{
-  char_u *p;
-
-  for (p = varname; *p != NUL; ++p)
-    if (!eval_isnamec1(*p) && (p == varname || !ascii_isdigit(*p))
-        && *p != AUTOLOAD_CHAR) {
-      EMSG2(_(e_illvar), varname);
-      return FALSE;
-    }
-  return TRUE;
-}
+// TODO(ZyX-I): move to eval/expressions
 
-/// Check whether typval is locked
-///
-/// Also gives an error message.
+/// Check if a variable name is valid
 ///
-/// @param[in]  lock  Lock status.
-/// @param[in]  name  Value name, for use in error message.
-/// @param[in]  name_len  Value name length.
+/// @param[in]  varname  Variable name to check.
 ///
-/// @return True if value is locked.
-static bool tv_check_lock(const VarLockStatus lock,
-                          const char *const name,
-                          const size_t name_len)
-  FUNC_ATTR_WARN_UNUSED_RESULT
+/// @return false when variable name is not valid, true when it is. Also gives
+///         an error message if appropriate.
+bool valid_varname(const char *varname)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  const char *error_message = NULL;
-  switch (lock) {
-    case VAR_UNLOCKED: {
+  for (const char *p = varname; *p != NUL; p++) {
+    if (!eval_isnamec1((int)(uint8_t)(*p))
+        && (p == varname || !ascii_isdigit(*p))
+        && *p != AUTOLOAD_CHAR) {
+      emsgf(_(e_illvar), varname);
       return false;
     }
-    case VAR_LOCKED: {
-      error_message = N_("E741: Value is locked: %.*s");
-      break;
-    }
-    case VAR_FIXED: {
-      error_message = N_("E742: Cannot change value of %.*s");
-      break;
-    }
   }
-  assert(error_message != NULL);
-
-  const char *const unknown_name = _("Unknown");
-
-  emsgf(_(error_message), (name != NULL ? name_len : strlen(unknown_name)),
-        (name != NULL ? name : unknown_name));
-
   return true;
 }
 
@@ -20016,7 +19400,7 @@ int var_item_copy(const vimconv_T *const conv,
       to->vval.v_dict = from->vval.v_dict->dv_copydict;
       ++to->vval.v_dict->dv_refcount;
     } else {
-      to->vval.v_dict = dict_copy(conv, from->vval.v_dict, deep, copyID);
+      to->vval.v_dict = tv_dict_copy(conv, from->vval.v_dict, deep, copyID);
     }
     if (to->vval.v_dict == NULL)
       ret = FAIL;
@@ -20730,9 +20114,9 @@ void ex_function(exarg_T *eap)
 
     if (fudi.fd_dict != NULL) {
       if (fudi.fd_di == NULL) {
-        /* add new dict entry */
-        fudi.fd_di = dictitem_alloc(fudi.fd_newkey);
-        if (dict_add(fudi.fd_dict, fudi.fd_di) == FAIL) {
+        // Add new dict entry
+        fudi.fd_di = tv_dict_item_alloc((const char *)fudi.fd_newkey);
+        if (tv_dict_add(fudi.fd_dict, fudi.fd_di) == FAIL) {
           xfree(fudi.fd_di);
           xfree(fp);
           goto erret;
@@ -21002,7 +20386,7 @@ theend:
  */
 static int eval_fname_script(const char *const p)
 {
-  // Use mb_stricmp() because in Turkish comparing the "I" may not work with
+  // Use mb_strnicmp() because in Turkish comparing the "I" may not work with
   // the standard library function.
   if (p[0] == '<'
       && (mb_strnicmp((char_u *)p + 1, (char_u *)"SID>", 4) == 0
@@ -21558,9 +20942,9 @@ void ex_delfunction(exarg_T *eap)
     }
 
     if (fudi.fd_dict != NULL) {
-      /* Delete the dict item that refers to the function, it will
-       * invoke func_unref() and possibly delete the function. */
-      dictitem_remove(fudi.fd_dict, fudi.fd_di);
+      // Delete the dict item that refers to the function, it will
+      // invoke func_unref() and possibly delete the function.
+      tv_dict_item_remove(fudi.fd_dict, fudi.fd_di);
     } else {
       // A normal function (not a numbered function or lambda) has a
       // refcount of 1 for the entry in the hashtable.  When deleting
@@ -21675,6 +21059,11 @@ void func_unref(char_u *name)
 
 /// Unreference a Function: decrement the reference count and free it when it
 /// becomes zero.
+/// Unreference user function, freeing it if needed
+///
+/// Decrements the reference count and frees when it becomes zero.
+///
+/// @param  fp  Function to unreference.
 void func_ptr_unref(ufunc_T *fp)
 {
   if (fp != NULL && --fp->uf_refcount <= 0) {
@@ -21712,17 +21101,19 @@ void func_ptr_ref(ufunc_T *fp)
   }
 }
 
-/// Call a user function.
-static void
-call_user_func(
-    ufunc_T *fp,                // pointer to function
-    int argcount,               // nr of args
-    typval_T *argvars,          // arguments
-    typval_T *rettv,            // return value
-    linenr_T firstline,         // first line of range
-    linenr_T lastline,          // last line of range
-    dict_T *selfdict           // Dictionary for "self"
-)
+/// Call a user function
+///
+/// @param  fp  Function to call.
+/// @param[in]  argcount  Number of arguments.
+/// @param  argvars  Arguments.
+/// @param[out]  rettv  Return value.
+/// @param[in]  firstline  First line of range.
+/// @param[in]  lastline  Last line of range.
+/// @param  selfdict  Dictionary for "self" for dictionary functions.
+void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars,
+                    typval_T *rettv, linenr_T firstline, linenr_T lastline,
+                    dict_T *selfdict)
+  FUNC_ATTR_NONNULL_ARG(1, 3, 4)
 {
   char_u      *save_sourcing_name;
   linenr_T save_sourcing_lnum;
@@ -21796,7 +21187,7 @@ call_user_func(
     STRCPY(name, "self");
 #endif
     v->di_flags = DI_FLAGS_RO + DI_FLAGS_FIX;
-    hash_add(&fc->l_vars.dv_hashtab, DI2HIKEY(v));
+    tv_dict_add(&fc->l_vars, v);
     v->di_tv.v_type = VAR_DICT;
     v->di_tv.v_lock = 0;
     v->di_tv.vval.v_dict = selfdict;
@@ -21819,7 +21210,7 @@ call_user_func(
   STRCPY(name, "000");
 #endif
   v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
-  hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v));
+  tv_dict_add(&fc->l_avars, v);
   v->di_tv.v_type = VAR_LIST;
   v->di_tv.v_lock = VAR_FIXED;
   v->di_tv.vval.v_list = &fc->l_varlist;
@@ -21867,9 +21258,9 @@ call_user_func(
       // Named arguments can be accessed without the "a:" prefix in lambda
       // expressions. Add to the l: dict.
       copy_tv(&v->di_tv, &v->di_tv);
-      hash_add(&fc->l_vars.dv_hashtab, DI2HIKEY(v));
+      tv_dict_add(&fc->l_vars, v);
     } else {
-      hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v));
+      tv_dict_add(&fc->l_avars, v);
     }
 
     if (ai >= 0 && ai < MAX_FUNC_ARGS) {
@@ -22065,29 +21456,22 @@ call_user_func(
       && fc->fc_refcount <= 0) {
     free_funccal(fc, false);
   } else {
-    hashitem_T      *hi;
-    listitem_T      *li;
-    int todo;
-
     // "fc" is still in use.  This can happen when returning "a:000",
     // assigning "l:" to a global variable or defining a closure.
     // Link "fc" in the list for garbage collection later.
     fc->caller = previous_funccal;
     previous_funccal = fc;
 
-    /* Make a copy of the a: variables, since we didn't do that above. */
-    todo = (int)fc->l_avars.dv_hashtab.ht_used;
-    for (hi = fc->l_avars.dv_hashtab.ht_array; todo > 0; ++hi) {
-      if (!HASHITEM_EMPTY(hi)) {
-        --todo;
-        v = HI2DI(hi);
-        copy_tv(&v->di_tv, &v->di_tv);
-      }
-    }
+    // Make a copy of the a: variables, since we didn't do that above.
+    TV_DICT_ITER(&fc->l_avars, di, {
+      copy_tv(&di->di_tv, &di->di_tv);
+    });
 
-    /* Make a copy of the a:000 items, since we didn't do that above. */
-    for (li = fc->l_varlist.lv_first; li != NULL; li = li->li_next)
+    // Make a copy of the a:000 items, since we didn't do that above.
+    for (listitem_T *li = fc->l_varlist.lv_first; li != NULL;
+         li = li->li_next) {
       copy_tv(&li->li_tv, &li->li_tv);
+    }
   }
 
   if (--fp->uf_calls <= 0 && fp->uf_refcount <= 0) {
@@ -22194,7 +21578,7 @@ static void add_nr_var(dict_T *dp, dictitem_T *v, char *name, varnumber_T nr)
   STRCPY(v->di_key, name);
 #endif
   v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
-  hash_add(&dp->dv_hashtab, DI2HIKEY(v));
+  tv_dict_add(dp, v);
   v->di_tv.v_type = VAR_NUMBER;
   v->di_tv.v_lock = VAR_FIXED;
   v->di_tv.vval.v_number = nr;
@@ -22590,7 +21974,7 @@ const void *var_shada_iter(const void *const iter, const char **const name,
     hi = globvarht.ht_array;
     while ((size_t) (hi - hifirst) < hinum
            && (HASHITEM_EMPTY(hi)
-               || var_flavour(HI2DI(hi)->di_key) != VAR_FLAVOUR_SHADA)) {
+               || var_flavour(hi->hi_key) != VAR_FLAVOUR_SHADA)) {
       hi++;
     }
     if ((size_t) (hi - hifirst) == hinum) {
@@ -22599,11 +21983,10 @@ const void *var_shada_iter(const void *const iter, const char **const name,
   } else {
     hi = (const hashitem_T *) iter;
   }
-  *name = (char *) HI2DI(hi)->di_key;
-  copy_tv(&(HI2DI(hi)->di_tv), rettv);
-  while ((size_t) (++hi - hifirst) < hinum) {
-    if (!HASHITEM_EMPTY(hi)
-        && var_flavour(HI2DI(hi)->di_key) == VAR_FLAVOUR_SHADA) {
+  *name = (char *)TV_DICT_HI2DI(hi)->di_key;
+  copy_tv(&TV_DICT_HI2DI(hi)->di_tv, rettv);
+  while ((size_t)(++hi - hifirst) < hinum) {
+    if (!HASHITEM_EMPTY(hi) && var_flavour(hi->hi_key) == VAR_FLAVOUR_SHADA) {
       return hi;
     }
   }
@@ -22614,62 +21997,54 @@ void var_set_global(const char *const name, typval_T vartv)
 {
   funccall_T *const saved_current_funccal = current_funccal;
   current_funccal = NULL;
-  set_var((char_u *) name, &vartv, false);
+  set_var(name, &vartv, false);
   current_funccal = saved_current_funccal;
 }
 
 int store_session_globals(FILE *fd)
 {
-  hashitem_T  *hi;
-  dictitem_T  *this_var;
-  int todo;
-  char_u      *p, *t;
-
-  todo = (int)globvarht.ht_used;
-  for (hi = globvarht.ht_array; todo > 0; ++hi) {
-    if (!HASHITEM_EMPTY(hi)) {
-      --todo;
-      this_var = HI2DI(hi);
-      if ((this_var->di_tv.v_type == VAR_NUMBER
-           || this_var->di_tv.v_type == VAR_STRING)
-          && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
-        /* Escape special characters with a backslash.  Turn a LF and
-         * CR into \n and \r. */
-        p = vim_strsave_escaped(get_tv_string(&this_var->di_tv),
-            (char_u *)"\\\"\n\r");
-        for (t = p; *t != NUL; ++t)
-          if (*t == '\n')
-            *t = 'n';
-          else if (*t == '\r')
-            *t = 'r';
-        if ((fprintf(fd, "let %s = %c%s%c",
-                 this_var->di_key,
-                 (this_var->di_tv.v_type == VAR_STRING) ? '"'
-                 : ' ',
-                 p,
-                 (this_var->di_tv.v_type == VAR_STRING) ? '"'
-                 : ' ') < 0)
-            || put_eol(fd) == FAIL) {
-          xfree(p);
-          return FAIL;
+  TV_DICT_ITER(&globvardict, this_var, {
+    if ((this_var->di_tv.v_type == VAR_NUMBER
+         || this_var->di_tv.v_type == VAR_STRING)
+        && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
+      // Escape special characters with a backslash.  Turn a LF and
+      // CR into \n and \r.
+      char_u *const p = vim_strsave_escaped(get_tv_string(&this_var->di_tv),
+                                            (char_u *)"\\\"\n\r");
+      for (char_u *t = p; *t != NUL; t++) {
+        if (*t == '\n') {
+          *t = 'n';
+        } else if (*t == '\r') {
+          *t = 'r';
         }
+      }
+      if ((fprintf(fd, "let %s = %c%s%c",
+                   this_var->di_key,
+                   ((this_var->di_tv.v_type == VAR_STRING) ? '"'
+                    : ' '),
+                   p,
+                   ((this_var->di_tv.v_type == VAR_STRING) ? '"'
+                    : ' ')) < 0)
+          || put_eol(fd) == FAIL) {
         xfree(p);
-      } else if (this_var->di_tv.v_type == VAR_FLOAT
-                 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
-        float_T f = this_var->di_tv.vval.v_float;
-        int sign = ' ';
-
-        if (f < 0) {
-          f = -f;
-          sign = '-';
-        }
-        if ((fprintf(fd, "let %s = %c%f",
-                 this_var->di_key, sign, f) < 0)
-            || put_eol(fd) == FAIL)
-          return FAIL;
+        return FAIL;
+      }
+      xfree(p);
+    } else if (this_var->di_tv.v_type == VAR_FLOAT
+               && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
+      float_T f = this_var->di_tv.vval.v_float;
+      int sign = ' ';
+
+      if (f < 0) {
+        f = -f;
+        sign = '-';
+      }
+      if ((fprintf(fd, "let %s = %c%f", this_var->di_key, sign, f) < 0)
+          || put_eol(fd) == FAIL) {
+        return FAIL;
       }
     }
-  }
+  });
   return OK;
 }
 
@@ -23094,7 +22469,7 @@ static inline TerminalJobData *common_job_init(char **argv,
                                                bool pty,
                                                bool rpc,
                                                bool detach,
-                                               char *cwd)
+                                               const char *cwd)
 {
   TerminalJobData *data = xcalloc(1, sizeof(TerminalJobData));
   data->stopped = false;
@@ -23384,8 +22759,7 @@ static void on_job_event(JobEvent *ev)
   argv[2].v_lock = 0;
   argv[2].vval.v_string = (uint8_t *)ev->type;
 
-  typval_T rettv;
-  init_tv(&rettv);
+  typval_T rettv = TV_INITIAL_VALUE;
   callback_call(ev->callback, 3, argv, &rettv);
   tv_clear(&rettv);
 }
@@ -23499,91 +22873,3 @@ bool eval_has_provider(char *name)
 
   return false;
 }
-
-// Compute the `DictWatcher` address from a QUEUE node. This only exists for
-// .asan-blacklist (ASAN doesn't handle QUEUE_DATA pointer arithmetic).
-static DictWatcher *dictwatcher_node_data(QUEUE *q)
-  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET
-{
-  return QUEUE_DATA(q, DictWatcher, node);
-}
-
-// Send a change notification to all `dict` watchers that match `key`.
-static void dictwatcher_notify(dict_T *dict, const char *key, typval_T *newtv,
-    typval_T *oldtv)
-  FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_NONNULL_ARG(2)
-{
-  typval_T argv[4];
-  for (size_t i = 0; i < ARRAY_SIZE(argv); i++) {
-    init_tv(argv + i);
-  }
-
-  argv[0].v_type = VAR_DICT;
-  argv[0].vval.v_dict = dict;
-  argv[1].v_type = VAR_STRING;
-  argv[1].vval.v_string = (char_u *)xstrdup(key);
-  argv[2].v_type = VAR_DICT;
-  argv[2].vval.v_dict = dict_alloc();
-  argv[2].vval.v_dict->dv_refcount++;
-
-  if (newtv) {
-    dictitem_T *v = dictitem_alloc((char_u *)"new");
-    copy_tv(newtv, &v->di_tv);
-    dict_add(argv[2].vval.v_dict, v);
-  }
-
-  if (oldtv) {
-    dictitem_T *v = dictitem_alloc((char_u *)"old");
-    copy_tv(oldtv, &v->di_tv);
-    dict_add(argv[2].vval.v_dict, v);
-  }
-
-  typval_T rettv;
-
-  QUEUE *w;
-  QUEUE_FOREACH(w, &dict->watchers) {
-    DictWatcher *watcher = dictwatcher_node_data(w);
-    if (!watcher->busy && dictwatcher_matches(watcher, key)) {
-      init_tv(&rettv);
-      watcher->busy = true;
-      callback_call(&watcher->callback, 3, argv, &rettv);
-      watcher->busy = false;
-      tv_clear(&rettv);
-    }
-  }
-
-  for (size_t i = 1; i < ARRAY_SIZE(argv); i++) {
-    tv_clear(argv + i);
-  }
-}
-
-// Test if `key` matches with with `watcher->key_pattern`
-static bool dictwatcher_matches(DictWatcher *watcher, const char *key)
-  FUNC_ATTR_NONNULL_ALL
-{
-  // For now only allow very simple globbing in key patterns: a '*' at the end
-  // of the string means it should match everything up to the '*' instead of the
-  // whole string.
-  char *nul = strchr(watcher->key_pattern, NUL);
-  size_t len = nul - watcher->key_pattern;
-  if (*(nul - 1) == '*') {
-    return !strncmp(key, watcher->key_pattern, len - 1);
-  } else {
-    return !strcmp(key, watcher->key_pattern);
-  }
-}
-
-// Perform all necessary cleanup for a `DictWatcher` instance.
-static void dictwatcher_free(DictWatcher *watcher)
-  FUNC_ATTR_NONNULL_ALL
-{
-  callback_free(&watcher->callback);
-  xfree(watcher->key_pattern);
-  xfree(watcher);
-}
-
-// Check if `d` has at least one watcher.
-static bool is_watched(dict_T *d)
-{
-  return d && !QUEUE_EMPTY(&d->watchers);
-}
diff --git a/src/nvim/eval.h b/src/nvim/eval.h
index 57fee5c5a2..7f6fd76c46 100644
--- a/src/nvim/eval.h
+++ b/src/nvim/eval.h
@@ -1,21 +1,23 @@
 #ifndef NVIM_EVAL_H
 #define NVIM_EVAL_H
 
-#include "nvim/profile.h"
 #include "nvim/hashtab.h"  // For hashtab_T
-#include "nvim/garray.h"  // For garray_T
 #include "nvim/buffer_defs.h"  // For scid_T
 #include "nvim/ex_cmds_defs.h"  // For exarg_T
+#include "nvim/eval/typval.h"
+#include "nvim/profile.h"
+#include "nvim/garray.h"
 
 #define COPYID_INC 2
 #define COPYID_MASK (~0x1)
 
 // All user-defined functions are found in this hashtable.
 extern hashtab_T func_hashtab;
+
 // From user function to hashitem and back.
 EXTERN ufunc_T dumuf;
 #define UF2HIKEY(fp) ((fp)->uf_name)
-#define HIKEY2UF(p)  ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
+#define HIKEY2UF(p)  ((ufunc_T *)(p - offsetof(ufunc_T, uf_name)))
 #define HI2UF(hi)    HIKEY2UF((hi)->hi_key)
 
 /// Defines for Vim variables
diff --git a/src/nvim/eval/decode.c b/src/nvim/eval/decode.c
index 1d30f51f55..3cb68e093b 100644
--- a/src/nvim/eval/decode.c
+++ b/src/nvim/eval/decode.c
@@ -6,6 +6,7 @@
 #include "nvim/eval.h"
 #include "nvim/eval/encode.h"
 #include "nvim/ascii.h"
+#include "nvim/macros.h"
 #include "nvim/message.h"
 #include "nvim/charset.h"  // vim_str2nr
 #include "nvim/lib/kvec.h"
@@ -51,16 +52,16 @@ static inline void create_special_dict(typval_T *const rettv,
                                        typval_T val)
   FUNC_ATTR_NONNULL_ALL
 {
-  dict_T *const dict = dict_alloc();
-  dictitem_T *const type_di = dictitem_alloc((char_u *) "_TYPE");
+  dict_T *const dict = tv_dict_alloc();
+  dictitem_T *const type_di = tv_dict_item_alloc_len(S_LEN("_TYPE"));
   type_di->di_tv.v_type = VAR_LIST;
   type_di->di_tv.v_lock = VAR_UNLOCKED;
   type_di->di_tv.vval.v_list = (list_T *) eval_msgpack_type_lists[type];
   type_di->di_tv.vval.v_list->lv_refcount++;
-  dict_add(dict, type_di);
-  dictitem_T *const val_di = dictitem_alloc((char_u *) "_VAL");
+  tv_dict_add(dict, type_di);
+  dictitem_T *const val_di = tv_dict_item_alloc_len(S_LEN("_VAL"));
   val_di->di_tv = val;
-  dict_add(dict, val_di);
+  tv_dict_add(dict, val_di);
   dict->dv_refcount++;
   *rettv = (typval_T) {
     .v_type = VAR_DICT,
@@ -138,9 +139,10 @@ static inline int json_decoder_pop(ValuesStackItem obj,
       assert(!(key.is_special_string
                || key.val.vval.v_string == NULL
                || *key.val.vval.v_string == NUL));
-      dictitem_T *obj_di = dictitem_alloc(key.val.vval.v_string);
+      dictitem_T *const obj_di = tv_dict_item_alloc(
+          (const char *)key.val.vval.v_string);
       tv_clear(&key.val);
-      if (dict_add(last_container.container.vval.v_dict, obj_di)
+      if (tv_dict_add(last_container.container.vval.v_dict, obj_di)
           == FAIL) {
         assert(false);
       }
@@ -173,8 +175,8 @@ static inline int json_decoder_pop(ValuesStackItem obj,
         && (obj.is_special_string
             || obj.val.vval.v_string == NULL
             || *obj.val.vval.v_string == NUL
-            || dict_find(last_container.container.vval.v_dict,
-                         obj.val.vval.v_string, -1))) {
+            || tv_dict_find(last_container.container.vval.v_dict,
+                            (const char *)obj.val.vval.v_string, -1))) {
       tv_clear(&obj.val);
 
       // Restart
@@ -835,7 +837,7 @@ json_decode_string_cycle_start:
             .vval = { .v_list = val_list },
           }));
         } else {
-          dict_T *dict = dict_alloc();
+          dict_T *dict = tv_dict_alloc();
           dict->dv_refcount++;
           tv = (typval_T) {
             .v_type = VAR_DICT,
@@ -1042,7 +1044,7 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
           goto msgpack_to_vim_generic_map;
         }
       }
-      dict_T *const dict = dict_alloc();
+      dict_T *const dict = tv_dict_alloc();
       dict->dv_refcount++;
       *rettv = (typval_T) {
         .v_type = VAR_DICT,
@@ -1055,7 +1057,7 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
         memcpy(&di->di_key[0], mobj.via.map.ptr[i].key.via.str.ptr,
                mobj.via.map.ptr[i].key.via.str.size);
         di->di_tv.v_type = VAR_UNKNOWN;
-        if (dict_add(dict, di) == FAIL) {
+        if (tv_dict_add(dict, di) == FAIL) {
           // Duplicate key: fallback to generic map
           tv_clear(rettv);
           xfree(di);
diff --git a/src/nvim/eval/encode.c b/src/nvim/eval/encode.c
index 1416806ca6..26f9aaa27d 100644
--- a/src/nvim/eval/encode.c
+++ b/src/nvim/eval/encode.c
@@ -744,11 +744,11 @@ bool encode_check_json_key(const typval_T *const tv)
   }
   const dictitem_T *type_di;
   const dictitem_T *val_di;
-  if ((type_di = dict_find((dict_T *) spdict, (char_u *) "_TYPE", -1)) == NULL
+  if ((type_di = tv_dict_find(spdict, S_LEN("_TYPE"))) == NULL
       || type_di->di_tv.v_type != VAR_LIST
       || (type_di->di_tv.vval.v_list != eval_msgpack_type_lists[kMPString]
           && type_di->di_tv.vval.v_list != eval_msgpack_type_lists[kMPBinary])
-      || (val_di = dict_find((dict_T *) spdict, (char_u *) "_VAL", -1)) == NULL
+      || (val_di = tv_dict_find(spdict, S_LEN("_VAL"))) == NULL
       || val_di->di_tv.v_type != VAR_LIST) {
     return false;
   }
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 7726e106a1..bb7baed7d2 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -2,6 +2,7 @@
 #include <stdbool.h>
 #include <assert.h>
 
+#include "nvim/lib/queue.h"
 #include "nvim/eval/typval.h"
 #include "nvim/eval/gc.h"
 #include "nvim/eval/executor.h"
@@ -12,6 +13,9 @@
 #include "nvim/assert.h"
 #include "nvim/memory.h"
 #include "nvim/globals.h"
+#include "nvim/hashtab.h"
+#include "nvim/vim.h"
+#include "nvim/ascii.h"
 // TODO(ZyX-I): Move line_breakcheck out of misc1
 #include "nvim/misc1.h"  // For line_breakcheck
 
@@ -115,8 +119,7 @@ void tv_list_watch_fix(list_T *const l, const listitem_T *const item)
   }
 }
 
-//{{{2 Lists
-//{{{3 Alloc/free
+//{{{2 Alloc/free
 
 /// Allocate an empty list
 ///
@@ -205,7 +208,7 @@ void tv_list_unref(list_T *const l)
   }
 }
 
-//{{{3 Add/remove
+//{{{2 Add/remove
 
 /// Remove items "item" to "item2" from list "l".
 ///
@@ -406,7 +409,7 @@ void tv_list_append_number(list_T *const l, const varnumber_T n)
   tv_list_append(l, li);
 }
 
-//{{{3 Operations on the whole list
+//{{{2 Operations on the whole list
 
 /// Make a copy of list
 ///
@@ -596,6 +599,8 @@ int tv_list_join(garray_T *const gap, list_T *const l, const char *const sep)
 /// @param[in]  l2  Second list to compare.
 /// @param[in]  ic  True if case is to be ignored.
 /// @param[in]  recursive  True when used recursively.
+///
+/// @return True if lists are equal, false otherwise.
 bool tv_list_equal(list_T *const l1, list_T *const l2, const bool ic,
                    const bool recursive)
   FUNC_ATTR_WARN_UNUSED_RESULT
@@ -623,7 +628,7 @@ bool tv_list_equal(list_T *const l1, list_T *const l2, const bool ic,
   return true;
 }
 
-//{{{3 Indexing/searching
+//{{{2 Indexing/searching
 
 /// Locate item with a given index in a list and return it
 ///
@@ -761,6 +766,552 @@ long tv_list_idx_of_item(const list_T *const l, const listitem_T *const item)
   }
   return idx;
 }
+
+//{{{1 Dictionaries
+//{{{2 Dictionary watchers
+
+/// Perform all necessary cleanup for a `DictWatcher` instance
+///
+/// @param  watcher  Watcher to free.
+void tv_dict_watcher_free(DictWatcher *watcher)
+  FUNC_ATTR_NONNULL_ALL
+{
+  callback_free(&watcher->callback);
+  xfree(watcher->key_pattern);
+  xfree(watcher);
+}
+
+/// Test if `key` matches with with `watcher->key_pattern`
+///
+/// @param[in]  watcher  Watcher to check key pattern from.
+/// @param[in]  key  Key to check.
+///
+/// @return true if key matches, false otherwise.
+static bool tv_dict_watcher_matches(DictWatcher *watcher, const char *const key)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
+{
+  // For now only allow very simple globbing in key patterns: a '*' at the end
+  // of the string means it should match everything up to the '*' instead of the
+  // whole string.
+  const size_t len = strlen(watcher->key_pattern);
+  if (watcher->key_pattern[len - 1] == '*') {
+    return strncmp(key, watcher->key_pattern, len - 1) == 0;
+  } else {
+    return strcmp(key, watcher->key_pattern) == 0;
+  }
+}
+
+/// Send a change notification to all dictionary watchers that match given key
+///
+/// @param[in]  dict  Dictionary which was modified.
+/// @param[in]  key  Key which was modified.
+/// @param[in]  newtv  New key value.
+/// @param[in]  oldtv  Old key value.
+void tv_dict_watcher_notify(dict_T *const dict, const char *const key,
+                            typval_T *const newtv, typval_T *const oldtv)
+  FUNC_ATTR_NONNULL_ARG(1, 2)
+{
+  typval_T argv[3];
+
+  argv[0].v_type = VAR_DICT;
+  argv[0].v_lock = VAR_UNLOCKED;
+  argv[0].vval.v_dict = dict;
+  argv[1].v_type = VAR_STRING;
+  argv[1].v_lock = VAR_UNLOCKED;
+  argv[1].vval.v_string = (char_u *)xstrdup(key);
+  argv[2].v_type = VAR_DICT;
+  argv[2].v_lock = VAR_UNLOCKED;
+  argv[2].vval.v_dict = tv_dict_alloc();
+  argv[2].vval.v_dict->dv_refcount++;
+
+  if (newtv) {
+    dictitem_T *const v = tv_dict_item_alloc_len(S_LEN("new"));
+    copy_tv(newtv, &v->di_tv);
+    tv_dict_add(argv[2].vval.v_dict, v);
+  }
+
+  if (oldtv) {
+    dictitem_T *const v = tv_dict_item_alloc_len(S_LEN("old"));
+    copy_tv(oldtv, &v->di_tv);
+    tv_dict_add(argv[2].vval.v_dict, v);
+  }
+
+  typval_T rettv;
+
+  QUEUE *w;
+  QUEUE_FOREACH(w, &dict->watchers) {
+    DictWatcher *watcher = tv_dict_watcher_node_data(w);
+    if (!watcher->busy && tv_dict_watcher_matches(watcher, key)) {
+      rettv = TV_INITIAL_VALUE;
+      watcher->busy = true;
+      callback_call(&watcher->callback, 3, argv, &rettv);
+      watcher->busy = false;
+      tv_clear(&rettv);
+    }
+  }
+
+  for (size_t i = 1; i < ARRAY_SIZE(argv); i++) {
+    tv_clear(argv + i);
+  }
+}
+
+//{{{2 Dictionary item
+
+/// Allocate a dictionary item
+///
+/// @note that the value of the item (->di_tv) still needs to be initialized.
+///
+/// @param[in]  key  Key, is copied to the new item.
+/// @param[in]  key_len  Key length.
+///
+/// @return [allocated] new dictionary item.
+dictitem_T *tv_dict_item_alloc_len(const char *const key, const size_t key_len)
+  FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+  FUNC_ATTR_MALLOC
+{
+  dictitem_T *const di = xmalloc(offsetof(dictitem_T, di_key) + key_len + 1);
+  memcpy(di->di_key, key, key_len);
+  di->di_key[key_len] = NUL;
+  di->di_flags = DI_FLAGS_ALLOC;
+  return di;
+}
+
+/// Allocate a dictionary item
+///
+/// @note that the value of the item (->di_tv) still needs to be initialized.
+///
+/// @param[in]  key  Key, is copied to the new item.
+///
+/// @return [allocated] new dictionary item.
+dictitem_T *tv_dict_item_alloc(const char *const key)
+  FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+  FUNC_ATTR_MALLOC
+{
+  return tv_dict_item_alloc_len(key, strlen(key));
+}
+
+/// Free a dictionary item, also clearing the value
+///
+/// @param  item  Item to free.
+void tv_dict_item_free(dictitem_T *const item)
+  FUNC_ATTR_NONNULL_ALL
+{
+  tv_clear(&item->di_tv);
+  if (item->di_flags & DI_FLAGS_ALLOC) {
+    xfree(item);
+  }
+}
+
+/// Add item to dictionary
+///
+/// @param[out]  d  Dictionary to add to.
+/// @param[in]  item  Item to add.
+///
+/// @return FAIL if key already exists.
+int tv_dict_add(dict_T *const d, dictitem_T *const item)
+  FUNC_ATTR_NONNULL_ALL
+{
+  return hash_add(&d->dv_hashtab, item->di_key);
+}
+
+/// Make a copy of a dictionary item
+///
+/// @param[in]  di  Item to copy.
+///
+/// @return [allocated] new dictionary item.
+static dictitem_T *tv_dict_item_copy(dictitem_T *const di)
+  FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+  FUNC_ATTR_MALLOC
+{
+  dictitem_T *const new_di = tv_dict_item_alloc((const char *)di->di_key);
+  copy_tv(&di->di_tv, &new_di->di_tv);
+  return new_di;
+}
+
+/// Remove item from dictionary and free it
+///
+/// @param  dict  Dictionary to remove item from.
+/// @param  item  Item to remove.
+void tv_dict_item_remove(dict_T *const dict, dictitem_T *const item)
+  FUNC_ATTR_NONNULL_ALL
+{
+  hashitem_T *const hi = hash_find(&dict->dv_hashtab, item->di_key);
+  if (HASHITEM_EMPTY(hi)) {
+    emsgf(_(e_intern2), "tv_dict_item_remove()");
+  } else {
+    hash_remove(&dict->dv_hashtab, hi);
+  }
+  tv_dict_item_free(item);
+}
+
+//{{{2 Alloc/free
+
+/// Allocate an empty dictionary
+///
+/// @return [allocated] new dictionary.
+dict_T *tv_dict_alloc(void)
+  FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  dict_T *const d = xmalloc(sizeof(dict_T));
+
+  // Add the dict to the list of dicts for garbage collection.
+  if (gc_first_dict != NULL) {
+    gc_first_dict->dv_used_prev = d;
+  }
+  d->dv_used_next = gc_first_dict;
+  d->dv_used_prev = NULL;
+  gc_first_dict = d;
+
+  hash_init(&d->dv_hashtab);
+  d->dv_lock = VAR_UNLOCKED;
+  d->dv_scope = VAR_NO_SCOPE;
+  d->dv_refcount = 0;
+  d->dv_copyID = 0;
+  QUEUE_INIT(&d->watchers);
+
+  return d;
+}
+
+/// Free items contained in a dictionary
+///
+/// @param[in,out]  d  Dictionary to clear.
+void tv_dict_free_contents(dict_T *const d)
+  FUNC_ATTR_NONNULL_ALL
+{
+  // Lock the hashtab, we don't want it to resize while freeing items.
+  hash_lock(&d->dv_hashtab);
+  assert(d->dv_hashtab.ht_locked > 0);
+  HASHTAB_ITER(&d->dv_hashtab, hi, {
+    // Remove the item before deleting it, just in case there is
+    // something recursive causing trouble.
+    dictitem_T *const di = TV_DICT_HI2DI(hi);
+    hash_remove(&d->dv_hashtab, hi);
+    tv_dict_item_free(di);
+  });
+
+  while (!QUEUE_EMPTY(&d->watchers)) {
+    QUEUE *w = QUEUE_HEAD(&d->watchers);
+    QUEUE_REMOVE(w);
+    DictWatcher *watcher = tv_dict_watcher_node_data(w);
+    tv_dict_watcher_free(watcher);
+  }
+
+  hash_clear(&d->dv_hashtab);
+  d->dv_hashtab.ht_locked--;
+  hash_init(&d->dv_hashtab);
+}
+
+/// Free a dictionary itself, ignoring items it contains
+///
+/// Ignores the reference count.
+///
+/// @param[in,out]  d  Dictionary to free.
+void tv_dict_free_dict(dict_T *const d)
+  FUNC_ATTR_NONNULL_ALL
+{
+  // Remove the dict from the list of dicts for garbage collection.
+  if (d->dv_used_prev == NULL) {
+    gc_first_dict = d->dv_used_next;
+  } else {
+    d->dv_used_prev->dv_used_next = d->dv_used_next;
+  }
+  if (d->dv_used_next != NULL) {
+    d->dv_used_next->dv_used_prev = d->dv_used_prev;
+  }
+
+  xfree(d);
+}
+
+/// Free a dictionary, including all items it contains
+///
+/// Ignores the reference count.
+///
+/// @param  d  Dictionary to free.
+void tv_dict_free(dict_T *const d)
+  FUNC_ATTR_NONNULL_ALL
+{
+  if (!tv_in_free_unref_items) {
+    tv_dict_free_contents(d);
+    tv_dict_free_dict(d);
+  }
+}
+
+
+/// Unreference a dictionary
+///
+/// Decrements the reference count and frees dictionary when it becomes zero.
+///
+/// @param[in]  d  Dictionary to operate on.
+void tv_dict_unref(dict_T *const d)
+{
+  if (d != NULL && --d->dv_refcount <= 0) {
+    tv_dict_free(d);
+  }
+}
+
+//{{{2 Indexing/searching
+
+/// Find item in dictionary
+///
+/// @param[in]  d  Dictionary to check.
+/// @param[in]  key  Dictionary key.
+/// @param[in]  len  Key length. If negative, then strlen(key) is used.
+///
+/// @return found item or NULL if nothing was found.
+dictitem_T *tv_dict_find(const dict_T *const d, const char *const key,
+                         const ptrdiff_t len)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  hashitem_T *const hi = (len < 0
+                          ? hash_find(&d->dv_hashtab, (const char_u *)key)
+                          : hash_find_len(&d->dv_hashtab, key, (size_t)len));
+  if (HASHITEM_EMPTY(hi)) {
+    return NULL;
+  }
+  return TV_DICT_HI2DI(hi);
+}
+
+/// Get a number item from a dictionary
+///
+/// Returns 0 if the entry does not exist.
+///
+/// @param[in]  d  Dictionary to get item from.
+/// @param[in]  key  Key to find in dictionary.
+///
+/// @return Dictionary item.
+varnumber_T tv_dict_get_number(dict_T *const d, const char *const key)
+  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  dictitem_T *const di = tv_dict_find(d, key, -1);
+  if (di == NULL) {
+    return 0;
+  }
+  return get_tv_number(&di->di_tv);
+}
+
+/// Get a string item from a dictionary
+///
+/// @param[in]  d  Dictionary to get item from.
+/// @param[in]  key  Dictionary key.
+/// @param[in]  save  If true, returned string will be placed in the allocated
+///                   memory.
+///
+/// @return NULL if key does not exist, empty string in case of type error,
+///         string item value otherwise. If returned value is not NULL, it may
+///         be allocated depending on `save` argument.
+char *tv_dict_get_string(dict_T *const d, const char *const key,
+                         const bool save)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  static char numbuf[NUMBUFLEN];
+  const char *const s = tv_dict_get_string_buf(d, key, numbuf);
+  if (save && s != NULL) {
+    return xstrdup(s);
+  }
+  return (char *)s;
+}
+
+/// Get a string item from a dictionary
+///
+/// @param[in]  d  Dictionary to get item from.
+/// @param[in]  key  Dictionary key.
+/// @param[in]  numbuf  Numbuf for.
+///
+/// @return NULL if key does not exist, empty string in case of type error,
+///         string item value otherwise.
+const char *tv_dict_get_string_buf(dict_T *const d, const char *const key,
+                                   char *const numbuf)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  dictitem_T *const di = tv_dict_find(d, key, -1);
+  if (di == NULL) {
+    return NULL;
+  }
+  return (const char *)get_tv_string_buf(&di->di_tv, (char_u *)numbuf);
+}
+
+//{{{2 Operations on the whole dict
+
+/// Clear all the keys of a Dictionary. "d" remains a valid empty Dictionary.
+///
+/// @param  d  The Dictionary to clear
+void tv_dict_clear(dict_T *const d)
+  FUNC_ATTR_NONNULL_ALL
+{
+  hash_lock(&d->dv_hashtab);
+  assert(d->dv_hashtab.ht_locked > 0);
+
+  HASHTAB_ITER(&d->dv_hashtab, hi, {
+    tv_dict_item_free(TV_DICT_HI2DI(hi));
+    hash_remove(&d->dv_hashtab, hi);
+  });
+
+  hash_unlock(&d->dv_hashtab);
+}
+
+/// Extend dictionary with items from another dictionary
+///
+/// @param  d1  Dictionary to extend.
+/// @param[in]  d2  Dictionary to extend with.
+/// @param[in]  action  "error", "force", "keep":
+///
+///                     e*, including "error": duplicate key gives an error.
+///                     f*, including "force": duplicate d2 keys override d1.
+///                     other, including "keep": duplicate d2 keys ignored.
+void tv_dict_extend(dict_T *const d1, dict_T *const d2,
+                    const char *const action)
+  FUNC_ATTR_NONNULL_ALL
+{
+  const bool watched = tv_dict_is_watched(d1);
+  const char *const arg_errmsg = _("extend() argument");
+  const size_t arg_errmsg_len = strlen(arg_errmsg);
+
+  TV_DICT_ITER(d2, di2, {
+    dictitem_T *const di1 = tv_dict_find(d1, (const char *)di2->di_key, -1);
+    if (d1->dv_scope != VAR_NO_SCOPE) {
+      // Disallow replacing a builtin function in l: and g:.
+      // Check the key to be valid when adding to any scope.
+      if (d1->dv_scope == VAR_DEF_SCOPE
+          && di2->di_tv.v_type == VAR_FUNC
+          && !var_check_func_name((const char *)di2->di_key, di1 == NULL)) {
+        break;
+      }
+      if (!valid_varname((const char *)di2->di_key)) {
+        break;
+      }
+    }
+    if (di1 == NULL) {
+      dictitem_T *const new_di = tv_dict_item_copy(di2);
+      if (tv_dict_add(d1, new_di) == FAIL) {
+        tv_dict_item_free(new_di);
+      } else if (watched) {
+        tv_dict_watcher_notify(d1, (const char *)new_di->di_key, &new_di->di_tv,
+                               NULL);
+      }
+    } else if (*action == 'e') {
+      emsgf(_("E737: Key already exists: %s"), di2->di_key);
+      break;
+    } else if (*action == 'f' && di2 != di1) {
+      typval_T oldtv;
+
+      if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
+          || var_check_ro(di1->di_flags, arg_errmsg, arg_errmsg_len)) {
+        break;
+      }
+
+      if (watched) {
+        copy_tv(&di1->di_tv, &oldtv);
+      }
+
+      tv_clear(&di1->di_tv);
+      copy_tv(&di2->di_tv, &di1->di_tv);
+
+      if (watched) {
+        tv_dict_watcher_notify(d1, (const char *)di1->di_key, &di1->di_tv,
+                               &oldtv);
+        tv_clear(&oldtv);
+      }
+    }
+  });
+}
+
+/// Compare two dictionaries
+///
+/// @param[in]  d1  First dictionary.
+/// @param[in]  d2  Second dictionary.
+/// @param[in]  ic  True if case is to be ignored.
+/// @param[in]  recursive  True when used recursively.
+bool tv_dict_equal(dict_T *const d1, dict_T *const d2,
+                   const bool ic, const bool recursive)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  if (d1 == d2) {
+    return true;
+  }
+  if (d1 == NULL || d2 == NULL) {
+    return false;
+  }
+  if (tv_dict_len(d1) != tv_dict_len(d2)) {
+    return false;
+  }
+
+  TV_DICT_ITER(d1, di1, {
+    dictitem_T *const di2 = tv_dict_find(d2, (const char *)di1->di_key, -1);
+    if (di2 == NULL) {
+      return false;
+    }
+    if (!tv_equal(&di1->di_tv, &di2->di_tv, ic, recursive)) {
+      return false;
+    }
+  });
+  return true;
+}
+
+/// Make a copy of dictionary
+///
+/// @param[in]  conv  If non-NULL, then all internal strings will be converted.
+/// @param[in]  orig  Original dictionary to copy.
+/// @param[in]  deep  If false, then shallow copy will be done.
+/// @param[in]  copyID  See var_item_copy().
+///
+/// @return Copied dictionary. May be NULL in case original dictionary is NULL
+///         or some failure happens. The refcount of the new dictionary is set
+///         to 1.
+dict_T *tv_dict_copy(const vimconv_T *const conv,
+                     dict_T *const orig,
+                     const bool deep,
+                     const int copyID)
+{
+  if (orig == NULL) {
+    return NULL;
+  }
+
+  dict_T *copy = tv_dict_alloc();
+  if (copyID != 0) {
+    orig->dv_copyID = copyID;
+    orig->dv_copydict = copy;
+  }
+  TV_DICT_ITER(orig, di, {
+    if (got_int) {
+      break;
+    }
+    dictitem_T *new_di;
+    if (conv == NULL || conv->vc_type == CONV_NONE) {
+      new_di = tv_dict_item_alloc((const char *)di->di_key);
+    } else {
+      size_t len = STRLEN(di->di_key);
+      char *const key = (char *)string_convert(conv, di->di_key, &len);
+      if (key == NULL) {
+        new_di = tv_dict_item_alloc_len((const char *)di->di_key, len);
+      } else {
+        new_di = tv_dict_item_alloc_len(key, len);
+        xfree(key);
+      }
+    }
+    if (deep) {
+      if (var_item_copy(conv, &di->di_tv, &new_di->di_tv, deep,
+                        copyID) == FAIL) {
+        xfree(new_di);
+        break;
+      }
+    } else {
+      copy_tv(&di->di_tv, &new_di->di_tv);
+    }
+    if (tv_dict_add(copy, new_di) == FAIL) {
+      tv_dict_item_free(new_di);
+      break;
+    }
+  });
+
+  copy->dv_refcount++;
+  if (got_int) {
+    tv_dict_unref(copy);
+    copy = NULL;
+  }
+
+  return copy;
+}
+
 //{{{1 Generic typval operations
 //{{{2 Init/alloc/clear
 //{{{3 Alloc
@@ -783,6 +1334,21 @@ list_T *tv_list_alloc_ret(typval_T *const ret_tv)
   return l;
 }
 
+/// Allocate an empty dictionary for a return value
+///
+/// Also sets reference count.
+///
+/// @param[out]  ret_tv  Structure where dictionary is saved.
+void tv_dict_alloc_ret(typval_T *const ret_tv)
+  FUNC_ATTR_NONNULL_ALL
+{
+  dict_T *const d = tv_dict_alloc();
+  ret_tv->vval.v_dict = d;
+  ret_tv->v_type = VAR_DICT;
+  ret_tv->v_lock = VAR_UNLOCKED;
+  d->dv_refcount++;
+}
+
 //{{{3 Clear
 #define TYPVAL_ENCODE_ALLOW_SPECIALS false
 
@@ -884,7 +1450,7 @@ static inline void _nothing_conv_func_end(typval_T *const tv, const int copyID)
 #define TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, dict) \
     do { \
       assert((void *)&dict != (void *)&TYPVAL_ENCODE_NODICT_VAR); \
-      dict_unref((dict_T *)dict); \
+      tv_dict_unref((dict_T *)dict); \
       *((dict_T **)&dict) = NULL; \
       if (tv != NULL) { \
         ((typval_T *)tv)->v_lock = VAR_UNLOCKED; \
@@ -966,7 +1532,7 @@ static inline void _nothing_conv_dict_end(typval_T *const tv,
   FUNC_ATTR_ALWAYS_INLINE
 {
   if ((const void *)dictp != nodictvar) {
-    dict_unref(*dictp);
+    tv_dict_unref(*dictp);
     *dictp = NULL;
   }
 }
@@ -1077,13 +1643,9 @@ void tv_item_lock(typval_T *const tv, const int deep, const bool lock)
         CHANGE_LOCK(lock, d->dv_lock);
         if (deep < 0 || deep > 1) {
           // recursive: lock/unlock the items the List contains
-          int todo = (int)d->dv_hashtab.ht_used;
-          for (hashitem_T *hi = d->dv_hashtab.ht_array; todo > 0; hi++) {
-            if (!HASHITEM_EMPTY(hi)) {
-              todo--;
-              tv_item_lock(&HI2DI(hi)->di_tv, deep - 1, lock);
-            }
-          }
+          TV_DICT_ITER(d, di, {
+            tv_item_lock(&di->di_tv, deep - 1, lock);
+          });
         }
       }
       break;
@@ -1121,6 +1683,140 @@ bool tv_islocked(const typval_T *const tv)
               && (tv->vval.v_dict->dv_lock & VAR_LOCKED)));
 }
 
+/// Return true if typval is locked
+///
+/// Also gives an error message when typval is locked.
+///
+/// @param[in]  lock  Lock status.
+/// @param[in]  name  Variable name, used in the error message.
+/// @param[in]  use_gettext  True if variable name also is to be translated.
+///
+/// @return true if variable is locked, false otherwise.
+bool tv_check_lock(const VarLockStatus lock, const char *const name,
+                   const size_t name_len)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  const char *error_message = NULL;
+  switch (lock) {
+    case VAR_UNLOCKED: {
+      return false;
+    }
+    case VAR_LOCKED: {
+      error_message = N_("E741: Value is locked: %.*s");
+      break;
+    }
+    case VAR_FIXED: {
+      error_message = N_("E742: Cannot change value of %.*s");
+      break;
+    }
+  }
+  assert(error_message != NULL);
+
+  const char *const unknown_name = _("Unknown");
+
+  emsgf(_(error_message), (name != NULL ? name_len : strlen(unknown_name)),
+        (name != NULL ? name : unknown_name));
+
+  return true;
+}
+
+//{{{2 Comparison
+
+static int tv_equal_recurse_limit;
+
+/// Compare two VimL values
+///
+/// Like "==", but strings and numbers are different, as well as floats and
+/// numbers.
+///
+/// @warning Too nested structures may be considered equal even if they are not.
+///
+/// @param[in]  tv1  First value to compare.
+/// @param[in]  tv2  Second value to compare.
+/// @param[in]  ic  True if case is to be ignored.
+/// @param[in]  recursive  True when used recursively.
+///
+/// @return true if values are equal.
+bool tv_equal(typval_T *const tv1, typval_T *const tv2, const bool ic,
+              const bool recursive)
+  FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
+{
+  // TODO(ZyX-I): Make this not recursive
+  static int recursive_cnt = 0;  // Catch recursive loops.
+
+  if (!((tv1->v_type == VAR_FUNC || tv1->v_type == VAR_PARTIAL)
+        && (tv2->v_type == VAR_FUNC || tv2->v_type == VAR_PARTIAL))
+      && tv1->v_type != tv2->v_type) {
+    return false;
+  }
+
+  // Catch lists and dicts that have an endless loop by limiting
+  // recursiveness to a limit.  We guess they are equal then.
+  // A fixed limit has the problem of still taking an awful long time.
+  // Reduce the limit every time running into it. That should work fine for
+  // deeply linked structures that are not recursively linked and catch
+  // recursiveness quickly.
+  if (!recursive) {
+    tv_equal_recurse_limit = 1000;
+  }
+  if (recursive_cnt >= tv_equal_recurse_limit) {
+    tv_equal_recurse_limit--;
+    return true;
+  }
+
+  switch (tv1->v_type) {
+    case VAR_LIST: {
+      recursive_cnt++;
+      const bool r = tv_list_equal(tv1->vval.v_list, tv2->vval.v_list, ic,
+                                   true);
+      recursive_cnt--;
+      return r;
+    }
+    case VAR_DICT: {
+      recursive_cnt++;
+      const bool r = tv_dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic,
+                                   true);
+      recursive_cnt--;
+      return r;
+    }
+    case VAR_PARTIAL:
+    case VAR_FUNC: {
+      if ((tv1->v_type == VAR_PARTIAL && tv1->vval.v_partial == NULL)
+          || (tv2->v_type == VAR_PARTIAL && tv2->vval.v_partial == NULL)) {
+        return false;
+      }
+      recursive_cnt++;
+      const bool r = func_equal(tv1, tv2, ic);
+      recursive_cnt--;
+      return r;
+    }
+    case VAR_NUMBER: {
+      return tv1->vval.v_number == tv2->vval.v_number;
+    }
+    case VAR_FLOAT: {
+      return tv1->vval.v_float == tv2->vval.v_float;
+    }
+    case VAR_STRING: {
+      char buf1[NUMBUFLEN];
+      char buf2[NUMBUFLEN];
+      const char *s1 = (const char *)get_tv_string_buf(tv1, (char_u *)buf1);
+      const char *s2 = (const char *)get_tv_string_buf(tv2, (char_u *)buf2);
+      return mb_strcmp_ic((bool)ic, s1, s2) == 0;
+    }
+    case VAR_SPECIAL: {
+      return tv1->vval.v_special == tv2->vval.v_special;
+    }
+    case VAR_UNKNOWN: {
+      // VAR_UNKNOWN can be the result of an invalid expression, let’s say it
+      // does not equal anything, not even self.
+      return false;
+    }
+  }
+
+  assert(false);
+  return false;
+}
+
 //{{{2 Type checks
 
 /// Check that given value is a number or string
@@ -1135,37 +1831,37 @@ bool tv_islocked(const typval_T *const tv)
 bool tv_check_str_or_nr(const typval_T *const tv)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
 {
-    switch (tv->v_type) {
-      case VAR_NUMBER:
-      case VAR_STRING: {
-        return true;
-      }
-      case VAR_FLOAT: {
-        EMSG(_("E805: Expected a Number or a String, Float found"));
-        return false;
-      }
-      case VAR_PARTIAL:
-      case VAR_FUNC: {
-        EMSG(_("E703: Expected a Number or a String, Funcref found"));
-        return false;
-      }
-      case VAR_LIST: {
-        EMSG(_("E745: Expected a Number or a String, List found"));
-        return false;
-      }
-      case VAR_DICT: {
-        EMSG(_("E728: Expected a Number or a String, Dictionary found"));
-        return false;
-      }
-      case VAR_SPECIAL: {
-        EMSG(_("E5300: Expected a Number or a String"));
-        return false;
-      }
-      case VAR_UNKNOWN: {
-        EMSG2(_(e_intern2), "tv_check_str_or_nr(UNKNOWN)");
-        return false;
-      }
+  switch (tv->v_type) {
+    case VAR_NUMBER:
+    case VAR_STRING: {
+      return true;
     }
-    assert(false);
-    return false;
+    case VAR_FLOAT: {
+      emsgf(_("E805: Expected a Number or a String, Float found"));
+      return false;
+    }
+    case VAR_PARTIAL:
+    case VAR_FUNC: {
+      emsgf(_("E703: Expected a Number or a String, Funcref found"));
+      return false;
+    }
+    case VAR_LIST: {
+      emsgf(_("E745: Expected a Number or a String, List found"));
+      return false;
+    }
+    case VAR_DICT: {
+      emsgf(_("E728: Expected a Number or a String, Dictionary found"));
+      return false;
+    }
+    case VAR_SPECIAL: {
+      emsgf(_("E5300: Expected a Number or a String"));
+      return false;
+    }
+    case VAR_UNKNOWN: {
+      emsgf(_(e_intern2), "tv_check_str_or_nr(UNKNOWN)");
+      return false;
+    }
+  }
+  assert(false);
+  return false;
 }
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index cf83904ffc..6183397d12 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -8,6 +8,7 @@
 #include "nvim/hashtab.h"
 #include "nvim/garray.h"
 #include "nvim/mbyte.h"
+#include "nvim/func_attr.h"
 #include "nvim/lib/queue.h"
 #include "nvim/profile.h"  // for proftime_T
 #include "nvim/pos.h"      // for linenr_T
@@ -31,6 +32,31 @@ typedef struct listvar_S list_T;
 typedef struct dictvar_S dict_T;
 typedef struct partial_S partial_T;
 
+typedef struct ufunc ufunc_T;
+
+typedef enum {
+  kCallbackNone,
+  kCallbackFuncref,
+  kCallbackPartial,
+} CallbackType;
+
+typedef struct {
+  union {
+    char_u *funcref;
+    partial_T *partial;
+  } data;
+  CallbackType type;
+} Callback;
+#define CALLBACK_NONE ((Callback){ .type = kCallbackNone })
+
+/// Structure holding dictionary watcher
+typedef struct dict_watcher {
+  Callback callback;
+  char *key_pattern;
+  QUEUE node;
+  bool busy;  // prevent recursion if the dict is changed in the callback
+} DictWatcher;
+
 /// Special variable values
 typedef enum {
   kSpecialVarFalse,  ///< v:false
@@ -134,7 +160,7 @@ struct dictitem_S {
     struct { \
       typval_T di_tv;  /* Structure that holds scope dictionary itself. */ \
       uint8_t di_flags;  /* Flags. */ \
-      char_u di_key[KEY_LEN];  /* NUL. */ \
+      char_u di_key[KEY_LEN];  /* Key value. */ \
     }
 
 /// Structure to hold a scope dictionary
@@ -181,9 +207,7 @@ typedef int scid_T;
 // Structure to hold info for a function that is currently being executed.
 typedef struct funccall_S funccall_T;
 
-// Structure to hold info for a user function.
-typedef struct ufunc ufunc_T;
-
+/// Structure to hold info for a user function.
 struct ufunc {
   int          uf_varargs;       ///< variable nr of arguments
   int          uf_flags;
@@ -207,12 +231,12 @@ struct ufunc {
   int          uf_tml_idx;       ///< index of line being timed; -1 if none
   int          uf_tml_execed;    ///< line being timed was executed
   scid_T       uf_script_ID;     ///< ID of script where function was defined,
-                                 //   used for s: variables
+                                 ///< 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[1];       ///< name of function (actually longer); can
-                                 //   start with <SNR>123_ (<SNR> is K_SPECIAL
-                                 //   KS_EXTRA KE_SNR)
+                                 ///< start with <SNR>123_ (<SNR> is K_SPECIAL
+                                 ///< KS_EXTRA KE_SNR)
 };
 
 /// Maximum number of function arguments
@@ -245,24 +269,17 @@ typedef struct list_stack_S {
 // In a hashtab item "hi_key" points to "di_key" in a dictitem.
 // This avoids adding a pointer to the hashtab item.
 
-/// Convert a dictitem pointer to a hashitem key pointer
-#define DI2HIKEY(di) ((di)->di_key)
-
-/// Convert a hashitem key pointer to a dictitem pointer
-#define HIKEY2DI(p)  ((dictitem_T *)(p - offsetof(dictitem_T, di_key)))
-
-/// Convert a hashitem value pointer to a dictitem pointer
-#define HIVAL2DI(p) \
-    ((dictitem_T *)(((char *)p) - offsetof(dictitem_T, di_tv)))
-
 /// Convert a hashitem pointer to a dictitem pointer
-#define HI2DI(hi)     HIKEY2DI((hi)->hi_key)
+#define TV_DICT_HI2DI(hi) \
+    ((dictitem_T *)((hi)->hi_key - offsetof(dictitem_T, di_key)))
+
+static inline long tv_list_len(list_T *const l)
+  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
 /// Get the number of items in a list
 ///
 /// @param[in]  l  List to check.
 static inline long tv_list_len(list_T *const l)
-  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if (l == NULL) {
     return 0;
@@ -270,6 +287,64 @@ static inline long tv_list_len(list_T *const l)
   return l->lv_len;
 }
 
+static inline long tv_dict_len(const dict_T *const d)
+  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
+
+/// Get the number of items in a Dictionary
+///
+/// @param[in]  d  Dictionary to check.
+static inline long tv_dict_len(const dict_T *const d)
+{
+  if (d == NULL) {
+    return 0L;
+  }
+  return (long)d->dv_hashtab.ht_used;
+}
+
+static inline bool tv_dict_is_watched(const dict_T *const d)
+  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
+
+/// Check if dictionary is watched
+///
+/// @param[in]  d  Dictionary to check.
+///
+/// @return true if there is at least one watcher.
+static inline bool tv_dict_is_watched(const dict_T *const d)
+{
+  return d && !QUEUE_EMPTY(&d->watchers);
+}
+
+static inline DictWatcher *tv_dict_watcher_node_data(QUEUE *q)
+  REAL_FATTR_NONNULL_ALL REAL_FATTR_NONNULL_RET REAL_FATTR_PURE
+  REAL_FATTR_WARN_UNUSED_RESULT;
+
+/// Compute the `DictWatcher` address from a QUEUE node.
+///
+/// This only exists for .asan-blacklist (ASAN doesn't handle QUEUE_DATA pointer
+/// arithmetic).
+static inline DictWatcher *tv_dict_watcher_node_data(QUEUE *q)
+{
+  return QUEUE_DATA(q, DictWatcher, node);
+}
+
+/// Initialize VimL object
+///
+/// Initializes to unlocked VAR_UNKNOWN object.
+///
+/// @param[out]  tv  Object to initialize.
+static inline void tv_init(typval_T *const tv)
+{
+  if (tv != NULL) {
+    memset(tv, 0, sizeof(*tv));
+  }
+}
+
+#define TV_INITIAL_VALUE \
+    ((typval_T) { \
+      .v_type = VAR_UNKNOWN, \
+      .v_lock = VAR_UNLOCKED, \
+    })
+
 /// Empty string
 ///
 /// Needed for hack which allows not allocating empty string and still not
@@ -279,6 +354,21 @@ extern const char *const tv_empty_string;
 /// Specifies that free_unref_items() function has (not) been entered
 extern bool tv_in_free_unref_items;
 
+/// Iterate over a dictionary
+///
+/// @param[in]  d  Dictionary to iterate over.
+/// @param  di  Name of the variable with current dictitem_T entry.
+/// @param  code  Cycle body.
+#define TV_DICT_ITER(d, di, code) \
+    HASHTAB_ITER(&(d)->dv_hashtab, di##hi_, { \
+      { \
+        dictitem_T *const di = TV_DICT_HI2DI(di##hi_); \
+        { \
+          code \
+        } \
+      } \
+    })
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval/typval.h.generated.h"
 #endif
diff --git a/src/nvim/eval/typval_encode.c.h b/src/nvim/eval/typval_encode.c.h
index eb89a601ff..ad54eef4a0 100644
--- a/src/nvim/eval/typval_encode.c.h
+++ b/src/nvim/eval/typval_encode.c.h
@@ -406,11 +406,11 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
       const dictitem_T *val_di;
       if (TYPVAL_ENCODE_ALLOW_SPECIALS
           && tv->vval.v_dict->dv_hashtab.ht_used == 2
-          && (type_di = dict_find((dict_T *)tv->vval.v_dict,
-                                  (char_u *)"_TYPE", -1)) != NULL
+          && (type_di = tv_dict_find((dict_T *)tv->vval.v_dict,
+                                     S_LEN("_TYPE"))) != NULL
           && type_di->di_tv.v_type == VAR_LIST
-          && (val_di = dict_find((dict_T *)tv->vval.v_dict,
-                                 (char_u *)"_VAL", -1)) != NULL) {
+          && (val_di = tv_dict_find((dict_T *)tv->vval.v_dict,
+                                    S_LEN("_VAL"))) != NULL) {
         size_t i;
         for (i = 0; i < ARRAY_SIZE(eval_msgpack_type_lists); i++) {
           if (type_di->di_tv.vval.v_list == eval_msgpack_type_lists[i]) {
@@ -662,7 +662,7 @@ typval_encode_stop_converting_one_item:
         while (HASHITEM_EMPTY(cur_mpsv->data.d.hi)) {
           cur_mpsv->data.d.hi++;
         }
-        dictitem_T *const di = HI2DI(cur_mpsv->data.d.hi);
+        dictitem_T *const di = TV_DICT_HI2DI(cur_mpsv->data.d.hi);
         cur_mpsv->data.d.todo--;
         cur_mpsv->data.d.hi++;
         TYPVAL_ENCODE_CONV_STR_STRING(NULL, &di->di_key[0],
diff --git a/src/nvim/event/process.h b/src/nvim/event/process.h
index 5cbf7f9ce7..26d70a5e6d 100644
--- a/src/nvim/event/process.h
+++ b/src/nvim/event/process.h
@@ -21,7 +21,7 @@ struct process {
   int pid, status, refcount;
   // set to the hrtime of when process_stop was called for the process.
   uint64_t stopped_time;
-  char *cwd;
+  const char *cwd;
   char **argv;
   Stream *in, *out, *err;
   process_exit_cb cb;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 151a4d375f..9681527fee 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -4764,8 +4764,8 @@ void fix_help_buffer(void)
   char_u      *p;
   char_u      *rt;
 
-  /* set filetype to "help". */
-  set_option_value((char_u *)"ft", 0L, (char_u *)"help", OPT_LOCAL);
+  // Set filetype to "help".
+  set_option_value("ft", 0L, "help", OPT_LOCAL);
 
   if (!syntax_present(curwin)) {
     for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) {
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index e59a87b335..b84834d351 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -2073,9 +2073,9 @@ void ex_listdo(exarg_T *eap)
           // Clear 'shm' to avoid that the file message overwrites
           // any output from the command.
           p_shm_save = vim_strsave(p_shm);
-          set_option_value((char_u *)"shm", 0L, (char_u *)"", 0);
+          set_option_value("shm", 0L, "", 0);
           do_argfile(eap, i);
-          set_option_value((char_u *)"shm", 0L, p_shm_save, 0);
+          set_option_value("shm", 0L, (char *)p_shm_save, 0);
           xfree(p_shm_save);
         }
         if (curwin->w_arg_idx != i) {
@@ -2138,9 +2138,9 @@ void ex_listdo(exarg_T *eap)
         // Go to the next buffer.  Clear 'shm' to avoid that the file
         // message overwrites any output from the command.
         p_shm_save = vim_strsave(p_shm);
-        set_option_value((char_u *)"shm", 0L, (char_u *)"", 0);
+        set_option_value("shm", 0L, "", 0);
         goto_buffer(eap, DOBUF_FIRST, FORWARD, next_fnum);
-        set_option_value((char_u *)"shm", 0L, p_shm_save, 0);
+        set_option_value("shm", 0L, (char *)p_shm_save, 0);
         xfree(p_shm_save);
 
         // If autocommands took us elsewhere, quit here.
@@ -2496,16 +2496,16 @@ static int APP_BOTH;
 static void add_pack_plugin(char_u *fname, void *cookie)
 {
   char_u *p4, *p3, *p2, *p1, *p;
-  char_u *new_rtp;
-  char_u *ffname = (char_u *)fix_fname((char *)fname);
+
+  char *const ffname = fix_fname((char *)fname);
 
   if (ffname == NULL) {
     return;
   }
 
-  if (cookie != &APP_LOAD && strstr((char *)p_rtp, (char *)ffname) == NULL) {
+  if (cookie != &APP_LOAD && strstr((char *)p_rtp, ffname) == NULL) {
     // directory is not yet in 'runtimepath', add it
-    p4 = p3 = p2 = p1 = get_past_head(ffname);
+    p4 = p3 = p2 = p1 = get_past_head((char_u *)ffname);
     for (p = p1; *p; mb_ptr_adv(p)) {
       if (vim_ispathsep_nocolon(*p)) {
         p4 = p3; p3 = p2; p2 = p1; p1 = p;
@@ -2521,13 +2521,13 @@ static void add_pack_plugin(char_u *fname, void *cookie)
     *p4 = NUL;
 
     // Find "ffname" in "p_rtp", ignoring '/' vs '\' differences
-    size_t fname_len = STRLEN(ffname);
-    char_u *insp = p_rtp;
+    size_t fname_len = strlen(ffname);
+    const char *insp = (const char *)p_rtp;
     for (;;) {
-      if (vim_fnamencmp(insp, ffname, fname_len) == 0) {
+      if (path_fnamencmp(insp, ffname, fname_len) == 0) {
         break;
       }
-      insp = vim_strchr(insp, ',');
+      insp = strchr(insp, ',');
       if (insp == NULL) {
         break;
       }
@@ -2536,10 +2536,10 @@ static void add_pack_plugin(char_u *fname, void *cookie)
 
     if (insp == NULL) {
       // not found, append at the end
-      insp = p_rtp + STRLEN(p_rtp);
+      insp = (const char *)p_rtp + STRLEN(p_rtp);
     } else {
       // append after the matching directory.
-      insp += STRLEN(ffname);
+      insp += strlen(ffname);
       while (*insp != NUL && *insp != ',') {
         insp++;
       }
@@ -2547,31 +2547,40 @@ static void add_pack_plugin(char_u *fname, void *cookie)
     *p4 = c;
 
     // check if rtp/pack/name/start/name/after exists
-    char *afterdir = concat_fnames((char *)ffname, "after", true);
+    char *afterdir = concat_fnames(ffname, "after", true);
     size_t afterlen = 0;
     if (os_isdir((char_u *)afterdir)) {
-      afterlen = STRLEN(afterdir) + 1;  // add one for comma
+      afterlen = strlen(afterdir) + 1;  // add one for comma
     }
 
-    size_t oldlen = STRLEN(p_rtp);
-    size_t addlen = STRLEN(ffname) + 1;  // add one for comma
-    new_rtp = try_malloc(oldlen + addlen + afterlen + 1);  // add one for NUL
+    const size_t oldlen = STRLEN(p_rtp);
+    const size_t addlen = strlen(ffname) + 1;  // add one for comma
+    const size_t new_rtp_len = oldlen + addlen + afterlen + 1;
+    // add one for NUL -------------------------------------^
+    char *const new_rtp = try_malloc(new_rtp_len);
     if (new_rtp == NULL) {
       goto theend;
     }
-    uintptr_t keep = (uintptr_t)(insp - p_rtp);
+    const size_t keep = (size_t)(insp - (const char *)p_rtp);
+    size_t new_rtp_fill = 0;
     memmove(new_rtp, p_rtp, keep);
-    new_rtp[keep] = ',';
-    memmove(new_rtp + keep + 1, ffname, addlen);
+    new_rtp_fill += keep;
+    new_rtp[new_rtp_fill++] = ',';
+    memmove(new_rtp + new_rtp_fill, ffname, addlen);
+    new_rtp_fill += addlen - 1;
+    assert(new_rtp[new_rtp_fill] == NUL || new_rtp[new_rtp_fill] == ',');
     if (p_rtp[keep] != NUL) {
-      memmove(new_rtp + keep + addlen, p_rtp + keep,
-              oldlen - keep + 1);
+      memmove(new_rtp + new_rtp_fill, p_rtp + keep, oldlen - keep + 1);
+      new_rtp_fill += oldlen - keep;
     }
     if (afterlen > 0) {
-      STRCAT(new_rtp, ",");
-      STRCAT(new_rtp, afterdir);
+      assert(new_rtp[new_rtp_fill] == NUL);
+      new_rtp[new_rtp_fill++] = ',';
+      memmove(new_rtp + new_rtp_fill, afterdir, afterlen - 1);
+      new_rtp_fill += afterlen - 1;
     }
-    set_option_value((char_u *)"rtp", 0L, new_rtp, 0);
+    new_rtp[new_rtp_fill] = NUL;
+    set_option_value("rtp", 0L, new_rtp, 0);
     xfree(new_rtp);
     xfree(afterdir);
   }
@@ -2580,7 +2589,7 @@ static void add_pack_plugin(char_u *fname, void *cookie)
     static const char *plugpat = "%s/plugin/**/*.vim";  // NOLINT
     static const char *ftpat = "%s/ftdetect/*.vim";  // NOLINT
 
-    size_t len = STRLEN(ffname) + STRLEN(ftpat);
+    size_t len = strlen(ffname) + STRLEN(ftpat);
     char_u *pat = try_malloc(len + 1);
     if (pat == NULL) {
       goto theend;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index dc99c0771d..87fe52c119 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -9483,18 +9483,18 @@ void dialog_msg(char_u *buff, char *format, char_u *fname)
 static void ex_behave(exarg_T *eap)
 {
   if (STRCMP(eap->arg, "mswin") == 0) {
-    set_option_value((char_u *)"selection", 0L, (char_u *)"exclusive", 0);
-    set_option_value((char_u *)"selectmode", 0L, (char_u *)"mouse,key", 0);
-    set_option_value((char_u *)"mousemodel", 0L, (char_u *)"popup", 0);
-    set_option_value((char_u *)"keymodel", 0L,
-        (char_u *)"startsel,stopsel", 0);
+    set_option_value("selection", 0L, "exclusive", 0);
+    set_option_value("selectmode", 0L, "mouse,key", 0);
+    set_option_value("mousemodel", 0L, "popup", 0);
+    set_option_value("keymodel", 0L, "startsel,stopsel", 0);
   } else if (STRCMP(eap->arg, "xterm") == 0) {
-    set_option_value((char_u *)"selection", 0L, (char_u *)"inclusive", 0);
-    set_option_value((char_u *)"selectmode", 0L, (char_u *)"", 0);
-    set_option_value((char_u *)"mousemodel", 0L, (char_u *)"extend", 0);
-    set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
-  } else
+    set_option_value("selection", 0L, "inclusive", 0);
+    set_option_value("selectmode", 0L, "", 0);
+    set_option_value("mousemodel", 0L, "extend", 0);
+    set_option_value("keymodel", 0L, "", 0);
+  } else {
     EMSG2(_(e_invarg2), eap->arg);
+  }
 }
 
 /*
@@ -9608,8 +9608,9 @@ void filetype_maybe_enable(void)
  */
 static void ex_setfiletype(exarg_T *eap)
 {
-  if (!did_filetype)
-    set_option_value((char_u *)"filetype", 0L, eap->arg, OPT_LOCAL);
+  if (!did_filetype) {
+    set_option_value("filetype", 0L, (char *)eap->arg, OPT_LOCAL);
+  }
 }
 
 static void ex_digraphs(exarg_T *eap)
@@ -9695,7 +9696,8 @@ static void ex_match(exarg_T *eap)
 
       c = *end;
       *end = NUL;
-      match_add(curwin, g, p + 1, 10, id, NULL, NULL);
+      match_add(curwin, (const char *)g, (const char *)p + 1, 10, id,
+                NULL, NULL);
       xfree(g);
       *end = c;
     }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 9851ed5396..872b7fe365 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -5173,7 +5173,7 @@ static int ex_window(void)
   // Create empty command-line buffer.
   buf_open_scratch(0, "[Command Line]");
   // Command-line buffer has bufhidden=wipe, unlike a true "scratch" buffer.
-  set_option_value((char_u *)"bh", 0L, (char_u *)"wipe", OPT_LOCAL);
+  set_option_value("bh", 0L, "wipe", OPT_LOCAL);
   curwin->w_p_rl = cmdmsg_rl;
   cmdmsg_rl = false;
   curbuf->b_p_ma = true;
@@ -5191,7 +5191,7 @@ static int ex_window(void)
       add_map((char_u *)"<buffer> <Tab> <C-X><C-V>", INSERT);
       add_map((char_u *)"<buffer> <Tab> a<C-X><C-V>", NORMAL);
     }
-    set_option_value((char_u *)"ft", 0L, (char_u *)"vim", OPT_LOCAL);
+    set_option_value("ft", 0L, "vim", OPT_LOCAL);
   }
 
   /* Reset 'textwidth' after setting 'filetype' (the Vim filetype plugin
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index b73d9944ce..8ab6955042 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -1556,7 +1556,7 @@ void do_autocmd_dirchanged(char *new_dir, CdScope scope)
   apply_autocmds(EVENT_DIRCHANGED, (char_u *)buf, (char_u *)new_dir, false,
                  NULL);
 
-  dict_clear(dict);
+  tv_dict_clear(dict);
 
   recursive = false;
 }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 0c131d7b33..076ee13a80 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1881,9 +1881,8 @@ static int vgetorpeek(int advance)
                          (size_t)(mlen - typebuf.tb_maplen));
               }
 
-              del_typebuf(mlen, 0);               /* remove the chars */
-              set_option_value((char_u *)"paste",
-                  (long)!p_paste, NULL, 0);
+              del_typebuf(mlen, 0);  // Remove the chars.
+              set_option_value("paste", !p_paste, NULL, 0);
               if (!(State & INSERT)) {
                 msg_col = 0;
                 msg_row = (int)Rows - 1;
diff --git a/src/nvim/hashtab.c b/src/nvim/hashtab.c
index b14bb01c0e..354c9718ba 100644
--- a/src/nvim/hashtab.c
+++ b/src/nvim/hashtab.c
@@ -82,7 +82,7 @@ void hash_clear_all(hashtab_T *ht, unsigned int off)
 ///         used for that key.
 ///         WARNING: Returned pointer becomes invalid as soon as the hash table
 ///                  is changed in any way.
-hashitem_T *hash_find(hashtab_T *ht, const char_u *key)
+hashitem_T *hash_find(const hashtab_T *const ht, const char_u *const key)
 {
   return hash_lookup(ht, (const char *)key, STRLEN(key), hash_hash(key));
 }
@@ -99,7 +99,8 @@ hashitem_T *hash_find(hashtab_T *ht, const char_u *key)
 ///
 ///         @warning Returned pointer becomes invalid as soon as the hash table
 ///                  is changed in any way.
-hashitem_T *hash_find_len(hashtab_T *ht, const char *key, const size_t len)
+hashitem_T *hash_find_len(const hashtab_T *const ht, const char *const key,
+                          const size_t len)
 {
   return hash_lookup(ht, key, len, hash_hash_len(key, len));
 }
@@ -115,7 +116,7 @@ hashitem_T *hash_find_len(hashtab_T *ht, const char *key, const size_t len)
 ///         used for that key.
 ///         WARNING: Returned pointer becomes invalid as soon as the hash table
 ///                  is changed in any way.
-hashitem_T *hash_lookup(hashtab_T *const ht,
+hashitem_T *hash_lookup(const hashtab_T *const ht,
                         const char *const key, const size_t key_len,
                         const hash_T hash)
 {
diff --git a/src/nvim/hashtab.h b/src/nvim/hashtab.h
index 0da2b13f2e..973b97d476 100644
--- a/src/nvim/hashtab.h
+++ b/src/nvim/hashtab.h
@@ -70,6 +70,25 @@ typedef struct hashtable_S {
   hashitem_T ht_smallarray[HT_INIT_SIZE];      /// initial array
 } hashtab_T;
 
+/// Iterate over a hashtab
+///
+/// @param[in]  ht  Hashtab to iterate over.
+/// @param  hi  Name of the variable with current hashtab entry.
+/// @param  code  Cycle body.
+#define HASHTAB_ITER(ht, hi, code) \
+    do { \
+      hashtab_T *const hi##ht_ = (ht); \
+      size_t hi##todo_ = hi##ht_->ht_used; \
+      for (hashitem_T *hi = hi##ht_->ht_array; hi##todo_; hi++) { \
+        if (!HASHITEM_EMPTY(hi)) { \
+          { \
+            code \
+          } \
+          hi##todo_--; \
+        } \
+      } \
+    } while (0)
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "hashtab.h.generated.h"
 #endif
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index 650bf76156..5042663041 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -19,6 +19,15 @@
 # define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
 #endif
 
+/// String with length
+///
+/// For use in functions which accept (char *s, size_t len) pair in arguments.
+///
+/// @param[in]  s  Static string.
+///
+/// @return `s, sizeof(s) - 1`
+#define S_LEN(s) (s), (sizeof(s) - 1)
+
 /*
  * Position comparisons
  */
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 0c978dc47d..33e1551351 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -803,17 +803,18 @@ static void command_line_scan(mparm_T *parmp)
             argv_idx = -1;                /* skip to next argument */
           break;
 
-        case 'A':                 /* "-A" start in Arabic mode */
-          set_option_value((char_u *)"arabic", 1L, NULL, 0);
+        case 'A': {  // "-A" start in Arabic mode.
+          set_option_value("arabic", 1L, NULL, 0);
           break;
-
-        case 'b':                 /* "-b" binary mode */
-          /* Needs to be effective before expanding file names, because
-           * for Win32 this makes us edit a shortcut file itself,
-           * instead of the file it links to. */
+        }
+        case 'b': {  // "-b" binary mode.
+          // Needs to be effective before expanding file names, because
+          // for Win32 this makes us edit a shortcut file itself,
+          // instead of the file it links to.
           set_options_bin(curbuf->b_p_bin, 1, 0);
-          curbuf->b_p_bin = 1;                /* binary file I/O */
+          curbuf->b_p_bin = 1;  // Binary file I/O.
           break;
+        }
 
         case 'e':                 /* "-e" Ex mode */
           exmode_active = EXMODE_NORMAL;
@@ -830,24 +831,27 @@ static void command_line_scan(mparm_T *parmp)
           main_start_gui();
           break;
 
-        case 'F':                 /* "-F" start in Farsi mode: rl + fkmap set */
-          p_fkmap = TRUE;
-          set_option_value((char_u *)"rl", 1L, NULL, 0);
+        case 'F': {  // "-F" start in Farsi mode: rl + fkmap set.
+          p_fkmap = true;
+          set_option_value("rl", 1L, NULL, 0);
           break;
+        }
 
         case 'h':                 /* "-h" give help message */
           usage();
           mch_exit(0);
 
-        case 'H':                 /* "-H" start in Hebrew mode: rl + hkmap set */
-          p_hkmap = TRUE;
-          set_option_value((char_u *)"rl", 1L, NULL, 0);
+        case 'H': {  // "-H" start in Hebrew mode: rl + hkmap set.
+          p_hkmap = true;
+          set_option_value("rl", 1L, NULL, 0);
           break;
+        }
 
-        case 'l':                 /* "-l" lisp mode, 'lisp' and 'showmatch' on */
-          set_option_value((char_u *)"lisp", 1L, NULL, 0);
-          p_sm = TRUE;
+        case 'l': {  // "-l" lisp mode, 'lisp' and 'showmatch' on.
+          set_option_value("lisp", 1L, NULL, 0);
+          p_sm = true;
           break;
+        }
 
         case 'M':                 /* "-M"  no changes or writing of files */
           reset_modifiable();
@@ -946,8 +950,7 @@ static void command_line_scan(mparm_T *parmp)
           /* default is 10: a little bit verbose */
           p_verbose = get_number_arg(argv[0], &argv_idx, 10);
           if (argv[0][argv_idx] != NUL) {
-            set_option_value((char_u *)"verbosefile", 0L,
-                (char_u *)argv[0] + argv_idx, 0);
+            set_option_value("verbosefile", 0L, argv[0] + argv_idx, 0);
             argv_idx = (int)STRLEN(argv[0]);
           }
           break;
@@ -956,7 +959,7 @@ static void command_line_scan(mparm_T *parmp)
           /* "-w {scriptout}"	write to script */
           if (ascii_isdigit(((char_u *)argv[0])[argv_idx])) {
             n = get_number_arg(argv[0], &argv_idx, 10);
-            set_option_value((char_u *)"window", n, NULL, 0);
+            set_option_value("window", n, NULL, 0);
             break;
           }
           want_argument = TRUE;
@@ -1088,7 +1091,7 @@ scripterror:
             if (ascii_isdigit(*((char_u *)argv[0]))) {
               argv_idx = 0;
               n = get_number_arg(argv[0], &argv_idx, 10);
-              set_option_value((char_u *)"window", n, NULL, 0);
+              set_option_value("window", n, NULL, 0);
               argv_idx = -1;
               break;
             }
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 1d1e13e7e0..ae94ec7ecd 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -62,7 +62,7 @@ int setmark(int c)
 /// Free fmark_T item
 void free_fmark(fmark_T fm)
 {
-  dict_unref(fm.additional_data);
+  tv_dict_unref(fm.additional_data);
 }
 
 /// Free xfmark_T item
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 57518a9535..621fa6fefc 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -583,7 +583,7 @@ int utf_ptr2char(const char_u *p)
  * If byte sequence is illegal or incomplete, returns -1 and does not advance
  * "s".
  */
-static int utf_safe_read_char_adv(char_u **s, size_t *n)
+static int utf_safe_read_char_adv(const char_u **s, size_t *n)
 {
   int c;
 
@@ -1233,7 +1233,8 @@ bool utf_isupper(int a)
   return utf_tolower(a) != a;
 }
 
-static int utf_strnicmp(char_u *s1, char_u *s2, size_t n1, size_t n2)
+static int utf_strnicmp(const char_u *s1, const char_u *s2, size_t n1,
+                        size_t n2)
 {
   int c1, c2, cdiff;
   char_u buffer[6];
@@ -1392,19 +1393,26 @@ int utf16_to_utf8(const WCHAR *strw, char **str)
  * Returns zero if s1 and s2 are equal (ignoring case), the difference between
  * two characters otherwise.
  */
-int mb_strnicmp(char_u *s1, char_u *s2, size_t nn)
+int mb_strnicmp(const char_u *s1, const char_u *s2, const size_t nn)
 {
   return utf_strnicmp(s1, s2, nn, nn);
 }
 
-/* We need to call mb_stricmp() even when we aren't dealing with a multi-byte
- * encoding because mb_stricmp() takes care of all ascii and non-ascii
- * encodings, including characters with umlauts in latin1, etc., while
- * STRICMP() only handles the system locale version, which often does not
- * handle non-ascii properly. */
-int mb_stricmp(char_u *s1, char_u *s2)
+/// Compare strings case-insensitively
+///
+/// @note We need to call mb_stricmp() even when we aren't dealing with
+///       a multi-byte encoding because mb_stricmp() takes care of all ASCII and
+///       non-ascii encodings, including characters with umlauts in latin1,
+///       etc., while STRICMP() only handles the system locale version, which
+///       often does not handle non-ascii properly.
+///
+/// @param[in]  s1  First string to compare, not more then #MAXCOL characters.
+/// @param[in]  s2  Second string to compare, not more then #MAXCOL characters.
+///
+/// @return 0 if strings are equal, <0 if s1 < s2, >0 if s1 > s2.
+int mb_stricmp(const char *s1, const char *s2)
 {
-  return mb_strnicmp(s1, s2, MAXCOL);
+  return mb_strnicmp((const char_u *)s1, (const char_u *)s2, MAXCOL);
 }
 
 /*
@@ -2020,8 +2028,8 @@ void * my_iconv_open(char_u *to, char_u *from)
  * Returns the converted string in allocated memory.  NULL for an error.
  * If resultlenp is not NULL, sets it to the result length in bytes.
  */
-static char_u * iconv_string(vimconv_T *vcp, char_u *str, size_t slen,
-                             size_t *unconvlenp, size_t *resultlenp)
+static char_u *iconv_string(const vimconv_T *const vcp, char_u *str,
+                            size_t slen, size_t *unconvlenp, size_t *resultlenp)
 {
   const char  *from;
   size_t fromlen;
@@ -2306,7 +2314,7 @@ int convert_setup_ext(vimconv_T *vcp, char_u *from, bool from_unicode_is_utf8,
  * Illegal chars are often changed to "?", unless vcp->vc_fail is set.
  * When something goes wrong, NULL is returned and "*lenp" is unchanged.
  */
-char_u * string_convert(vimconv_T *vcp, char_u *ptr, size_t *lenp)
+char_u *string_convert(const vimconv_T *const vcp, char_u *ptr, size_t *lenp)
 {
   return string_convert_ext(vcp, ptr, lenp, NULL);
 }
@@ -2316,7 +2324,7 @@ char_u * string_convert(vimconv_T *vcp, char_u *ptr, size_t *lenp)
  * an incomplete sequence at the end it is not converted and "*unconvlenp" is
  * set to the number of remaining bytes.
  */
-char_u * string_convert_ext(vimconv_T *vcp, char_u *ptr,
+char_u * string_convert_ext(const vimconv_T *const vcp, char_u *ptr,
                             size_t *lenp, size_t *unconvlenp)
 {
   char_u      *retval = NULL;
diff --git a/src/nvim/mbyte.h b/src/nvim/mbyte.h
index 5f5bab9fcd..c20e6d47ff 100644
--- a/src/nvim/mbyte.h
+++ b/src/nvim/mbyte.h
@@ -2,8 +2,10 @@
 #define NVIM_MBYTE_H
 
 #include <stdbool.h>
+#include <string.h>
 
 #include "nvim/iconv.h"
+#include "nvim/func_attr.h"
 
 /*
  * Return byte length of character that starts with byte "b".
@@ -66,4 +68,17 @@ typedef struct {
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "mbyte.h.generated.h"
 #endif
+
+static inline int mb_strcmp_ic(bool ic, const char *s1, const char *s2)
+  REAL_FATTR_NONNULL_ALL REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
+
+/// Compare strings
+///
+/// @param[in]  ic  True if case is to be ignored.
+///
+/// @return 0 if s1 == s2, <0 if s1 < s2, >0 if s1 > s2.
+static inline int mb_strcmp_ic(bool ic, const char *s1, const char *s2)
+{
+  return (ic ? mb_stricmp(s1, s2) : strcmp(s1, s2));
+}
 #endif  // NVIM_MBYTE_H
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index f9d3751390..5ea2397db3 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -992,7 +992,7 @@ void ml_recover(void)
   if (b0_ff != 0)
     set_fileformat(b0_ff - 1, OPT_LOCAL);
   if (b0_fenc != NULL) {
-    set_option_value((char_u *)"fenc", 0L, b0_fenc, OPT_LOCAL);
+    set_option_value("fenc", 0L, (char *)b0_fenc, OPT_LOCAL);
     xfree(b0_fenc);
   }
   unchanged(curbuf, TRUE);
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 85cef59aec..d634a8c393 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -16,6 +16,7 @@
 #include "nvim/cursor.h"
 #include "nvim/edit.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/ex_cmds.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_getln.h"
@@ -888,7 +889,7 @@ static void set_yreg_additional_data(yankreg_T *reg, dict_T *additional_data)
   if (reg->additional_data == additional_data) {
     return;
   }
-  dict_unref(reg->additional_data);
+  tv_dict_unref(reg->additional_data);
   reg->additional_data = additional_data;
 }
 
@@ -2581,7 +2582,7 @@ static void do_autocmd_textyankpost(oparg_T *oap, yankreg_T *reg)
   textlock++;
   apply_autocmds(EVENT_TEXTYANKPOST, NULL, NULL, false, curbuf);
   textlock--;
-  dict_clear(dict);
+  tv_dict_clear(dict);
 
   recursive = false;
 }
diff --git a/src/nvim/option.c b/src/nvim/option.c
index b037b0ae35..4c8606a999 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -25,6 +25,7 @@
 #include <limits.h>
 
 #include "nvim/vim.h"
+#include "nvim/macros.h"
 #include "nvim/ascii.h"
 #include "nvim/edit.h"
 #include "nvim/option.h"
@@ -34,6 +35,7 @@
 #include "nvim/diff.h"
 #include "nvim/digraph.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
@@ -604,7 +606,7 @@ void set_init_1(void)
   /*
    * 'maxmemtot' and 'maxmem' may have to be adjusted for available memory
    */
-  opt_idx = findoption((char_u *)"maxmemtot");
+  opt_idx = findoption("maxmemtot");
   if (opt_idx >= 0) {
     {
       /* Use half of amount of memory available to Vim. */
@@ -614,7 +616,7 @@ void set_init_1(void)
                     ? UINTPTR_MAX
                     : (uintptr_t)(available_kib /2);
       options[opt_idx].def_val[VI_DEFAULT] = (char_u *)n;
-      opt_idx = findoption((char_u *)"maxmem");
+      opt_idx = findoption("maxmem");
       if (opt_idx >= 0) {
         options[opt_idx].def_val[VI_DEFAULT] = (char_u *)n;
       }
@@ -645,7 +647,7 @@ void set_init_1(void)
           }
         }
         buf[j] = NUL;
-        opt_idx = findoption((char_u *)"cdpath");
+        opt_idx = findoption("cdpath");
         if (opt_idx >= 0) {
           options[opt_idx].def_val[VI_DEFAULT] = buf;
           options[opt_idx].flags |= P_DEF_ALLOCED;
@@ -764,8 +766,9 @@ void set_init_1(void)
    * NOTE: mlterm's author is being asked to 'set' a variable
    *       instead of an environment variable due to inheritance.
    */
-  if (os_env_exists("MLTERM"))
-    set_option_value((char_u *)"tbidi", 1L, NULL, 0);
+  if (os_env_exists("MLTERM")) {
+    set_option_value("tbidi", 1L, NULL, 0);
+  }
 
   didset_options2();
 
@@ -775,7 +778,7 @@ void set_init_1(void)
   char_u *p = enc_locale();
   if (p == NULL) {
       // use utf-8 as 'default' if locale encoding can't be detected.
-      p = vim_strsave((char_u *)"utf-8");
+      p = (char_u *)xmemdupz(S_LEN("utf-8"));
   }
   fenc_default = p;
 
@@ -882,7 +885,7 @@ set_options_default (
 static void set_string_default(const char *name, char *val, bool allocated)
   FUNC_ATTR_NONNULL_ALL
 {
-  int opt_idx = findoption((char_u *)name);
+  int opt_idx = findoption(name);
   if (opt_idx >= 0) {
     if (options[opt_idx].flags & P_DEF_ALLOCED) {
       xfree(options[opt_idx].def_val[VI_DEFAULT]);
@@ -904,9 +907,10 @@ void set_number_default(char *name, long val)
 {
   int opt_idx;
 
-  opt_idx = findoption((char_u *)name);
-  if (opt_idx >= 0)
+  opt_idx = findoption(name);
+  if (opt_idx >= 0) {
     options[opt_idx].def_val[VI_DEFAULT] = (char_u *)val;
+  }
 }
 
 #if defined(EXITFREE)
@@ -947,17 +951,19 @@ void set_init_2(void)
    * wrong when the window height changes.
    */
   set_number_default("scroll", Rows / 2);
-  idx = findoption((char_u *)"scroll");
-  if (idx >= 0 && !(options[idx].flags & P_WAS_SET))
+  idx = findoption("scroll");
+  if (idx >= 0 && !(options[idx].flags & P_WAS_SET)) {
     set_option_default(idx, OPT_LOCAL, p_cp);
+  }
   comp_col();
 
   /*
    * 'window' is only for backwards compatibility with Vi.
    * Default is Rows - 1.
    */
-  if (!option_was_set((char_u *)"window"))
+  if (!option_was_set("window")) {
     p_window = Rows - 1;
+  }
   set_number_default("window", Rows - 1);
   parse_shape_opt(SHAPE_CURSOR);   /* set cursor shapes from 'guicursor' */
   (void)parse_printoptions();       /* parse 'printoptions' default value */
@@ -976,16 +982,18 @@ void set_init_3(void)
   int idx_sp;
   int do_sp;
 
-  idx_srr = findoption((char_u *)"srr");
-  if (idx_srr < 0)
-    do_srr = FALSE;
-  else
+  idx_srr = findoption("srr");
+  if (idx_srr < 0) {
+    do_srr = false;
+  } else {
     do_srr = !(options[idx_srr].flags & P_WAS_SET);
-  idx_sp = findoption((char_u *)"sp");
-  if (idx_sp < 0)
-    do_sp = FALSE;
-  else
+  }
+  idx_sp = findoption("sp");
+  if (idx_sp < 0) {
+    do_sp = false;
+  } else {
     do_sp = !(options[idx_sp].flags & P_WAS_SET);
+  }
 
   size_t len = 0;
   char_u *p = (char_u *)invocation_path_tail(p_sh, &len);
@@ -1029,7 +1037,7 @@ void set_init_3(void)
   }
 
   if (bufempty()) {
-    int idx_ffs = findoption((char_u *)"ffs");
+    int idx_ffs = findoption_len(S_LEN("ffs"));
 
     // Apply the first entry of 'fileformats' to the initial buffer.
     if (idx_ffs >= 0 && (options[idx_ffs].flags & P_WAS_SET)) {
@@ -1048,14 +1056,16 @@ void set_helplang_default(const char *lang)
 {
   int idx;
 
-  if (lang == NULL || STRLEN(lang) < 2)         /* safety check */
+  const size_t lang_len = strlen(lang);
+  if (lang == NULL || lang_len < 2) {  // safety check
     return;
-  idx = findoption((char_u *)"hlg");
+  }
+  idx = findoption("hlg");
   if (idx >= 0 && !(options[idx].flags & P_WAS_SET)) {
     if (options[idx].flags & P_ALLOCED)
       free_string_option(p_hlg);
-    p_hlg = (char_u *)xstrdup(lang);
-    /* zh_CN becomes "cn", zh_TW becomes "tw". */
+    p_hlg = (char_u *)xmemdupz(lang, lang_len);
+    // zh_CN becomes "cn", zh_TW becomes "tw".
     if (STRNICMP(p_hlg, "zh_", 3) == 0 && STRLEN(p_hlg) >= 5) {
       p_hlg[0] = (char_u)TOLOWER_ASC(p_hlg[3]);
       p_hlg[1] = (char_u)TOLOWER_ASC(p_hlg[4]);
@@ -1082,12 +1092,12 @@ void set_title_defaults(void)
    * icon name.  Saves a bit of time, because the X11 display server does
    * not need to be contacted.
    */
-  idx1 = findoption((char_u *)"title");
+  idx1 = findoption("title");
   if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
     options[idx1].def_val[VI_DEFAULT] = (char_u *)(intptr_t)0;
     p_title = 0;
   }
-  idx1 = findoption((char_u *)"icon");
+  idx1 = findoption("icon");
   if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
     options[idx1].def_val[VI_DEFAULT] = (char_u *)(intptr_t)0;
     p_icon = 0;
@@ -1193,7 +1203,7 @@ do_set (
           goto skip;
         }
         if (arg[1] == 't' && arg[2] == '_') {  // could be term code
-          opt_idx = findoption_len(arg + 1, (size_t) (len - 1));
+          opt_idx = findoption_len((const char *)arg + 1, (size_t)(len - 1));
         }
         len++;
         if (opt_idx == -1) {
@@ -1209,7 +1219,7 @@ do_set (
             len++;
           }
         }
-        opt_idx = findoption_len(arg, (size_t) len);
+        opt_idx = findoption_len((const char *)arg, (size_t)len);
         if (opt_idx == -1) {
           key = find_key_option(arg);
         }
@@ -1391,11 +1401,10 @@ do_set (
               value = prefix;
           }
 
-          errmsg = set_bool_option(opt_idx, varp, (int)value,
-              opt_flags);
-        } else {                                  /* numeric or string */
-          if (vim_strchr((char_u *)"=:&<", nextchar) == NULL
-              || prefix != 1) {
+          errmsg = (char_u *)set_bool_option(opt_idx, varp, (int)value,
+                                             opt_flags);
+        } else {  // Numeric or string.
+          if (strchr("=:&<", nextchar) == NULL || prefix != 1) {
             errmsg = e_invarg;
             goto skip;
           }
@@ -1448,15 +1457,19 @@ do_set (
               goto skip;
             }
 
-            if (adding)
+            if (adding) {
               value = *(long *)varp + value;
-            if (prepending)
+            }
+            if (prepending) {
               value = *(long *)varp * value;
-            if (removing)
+            }
+            if (removing) {
               value = *(long *)varp - value;
-            errmsg = set_num_option(opt_idx, varp, value,
-                errbuf, sizeof(errbuf), opt_flags);
-          } else if (opt_idx >= 0) {                      /* string */
+            }
+            errmsg = (char_u *)set_num_option(opt_idx, varp, value,
+                                              errbuf, sizeof(errbuf),
+                                              opt_flags);
+          } else if (opt_idx >= 0) {  // String.
             char_u      *save_arg = NULL;
             char_u      *s = NULL;
             char_u      *oldval = NULL;         // previous value if *varp
@@ -2221,7 +2234,7 @@ static void check_string_option(char_u **pp)
  */
 int was_set_insecurely(char_u *opt, int opt_flags)
 {
-  int idx = findoption(opt);
+  int idx = findoption((const char *)opt);
 
   if (idx >= 0) {
     uint32_t *flagp = insecure_flag(idx, opt_flags);
@@ -2283,9 +2296,9 @@ set_string_option_direct (
   int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
   int idx = opt_idx;
 
-  if (idx == -1) {              /* use name */
-    idx = findoption(name);
-    if (idx < 0) {      /* not found (should not happen) */
+  if (idx == -1) {  // Use name.
+    idx = findoption((const char *)name);
+    if (idx < 0) {  // Not found (should not happen).
       EMSG2(_(e_intern2), "set_string_option_direct()");
       EMSG2(_("For option %s"), name);
       return;
@@ -2765,7 +2778,7 @@ did_set_string_option (
     //              option.
     opt_idx = ((options[opt_idx].fullname[0] == 'v')
                ? (shada_idx == -1
-                  ? ((shada_idx = findoption((char_u *) "shada")))
+                  ? ((shada_idx = findoption("shada")))
                   : shada_idx)
                : opt_idx);
     // Update free_oldval now that we have the opt_idx for 'shada', otherwise
@@ -3575,24 +3588,24 @@ static void set_option_scriptID_idx(int opt_idx, int opt_flags, int id)
   }
 }
 
-/*
- * Set the value of a boolean option, and take care of side effects.
- * Returns NULL for success, or an error message for an error.
- */
-static char_u *
-set_bool_option (
-    int opt_idx,                            /* index in options[] table */
-    char_u *varp,                      /* pointer to the option variable */
-    int value,                              /* new value */
-    int opt_flags                          /* OPT_LOCAL and/or OPT_GLOBAL */
-)
+/// Set the value of a boolean option, taking care of side effects
+///
+/// @param[in]  opt_idx  Option index in options[] table.
+/// @param[out]  varp  Pointer to the option variable.
+/// @param[in]  value  New value.
+/// @param[in]  opt_flags  OPT_LOCAL and/or OPT_GLOBAL.
+///
+/// @return NULL on success, error message on error.
+static char *set_bool_option(const int opt_idx, char_u *const varp,
+                             const int value,
+                             const int opt_flags)
 {
   int old_value = *(int *)varp;
 
   /* Disallow changing some options from secure mode */
   if ((secure || sandbox != 0)
       && (options[opt_idx].flags & P_SECURE)) {
-    return e_secure;
+    return (char *)e_secure;
   }
 
   *(int *)varp = value;             /* set the new value */
@@ -3605,20 +3618,18 @@ set_bool_option (
     *(int *)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL) = value;
 
   // Ensure that options set to p_force_on cannot be disabled.
-  if ((int *)varp == &p_force_on && p_force_on == FALSE) {
-    p_force_on = TRUE;
-    return e_unsupportedoption;
-  }
+  if ((int *)varp == &p_force_on && p_force_on == false) {
+    p_force_on = true;
+    return (char *)e_unsupportedoption;
   // Ensure that options set to p_force_off cannot be enabled.
-  else if ((int *)varp == &p_force_off && p_force_off == TRUE) {
-    p_force_off = FALSE;
-    return e_unsupportedoption;
-  }
-  /* 'undofile' */
-  else if ((int *)varp == &curbuf->b_p_udf || (int *)varp == &p_udf) {
-    /* Only take action when the option was set. When reset we do not
-     * delete the undo file, the option may be set again without making
-     * any changes in between. */
+  } else if ((int *)varp == &p_force_off && p_force_off == true) {
+    p_force_off = false;
+    return (char *)e_unsupportedoption;
+  // 'undofile'
+  } else if ((int *)varp == &curbuf->b_p_udf || (int *)varp == &p_udf) {
+    // Only take action when the option was set. When reset we do not
+    // delete the undo file, the option may be set again without making
+    // any changes in between.
     if (curbuf->b_p_udf || p_udf) {
       char_u hash[UNDO_HASH_SIZE];
       buf_T       *save_curbuf = curbuf;
@@ -3740,8 +3751,8 @@ set_bool_option (
     if (curwin->w_p_pvw) {
       FOR_ALL_WINDOWS_IN_TAB(win, curtab) {
         if (win->w_p_pvw && win != curwin) {
-          curwin->w_p_pvw = FALSE;
-          return (char_u *)N_("E590: A preview window already exists");
+          curwin->w_p_pvw = false;
+          return N_("E590: A preview window already exists");
         }
       }
     }
@@ -3889,9 +3900,8 @@ set_bool_option (
       /* set 'delcombine' */
       p_deco = TRUE;
 
-      /* Force-set the necessary keymap for arabic */
-      set_option_value((char_u *)"keymap", 0L, (char_u *)"arabic",
-          OPT_LOCAL);
+      // Force-set the necessary keymap for arabic.
+      set_option_value("keymap", 0L, "arabic", OPT_LOCAL);
       p_altkeymap = 0;
       p_hkmap = 0;
       p_fkmap = 0;
@@ -3957,20 +3967,18 @@ set_bool_option (
   return NULL;
 }
 
-/*
- * Set the value of a number option, and take care of side effects.
- * Returns NULL for success, or an error message for an error.
- */
-static char_u *
-set_num_option (
-    int opt_idx,                            /* index in options[] table */
-    char_u *varp,                      /* pointer to the option variable */
-    long value,                             /* new value */
-    char_u *errbuf,                    /* buffer for error messages */
-    size_t errbuflen,                       /* length of "errbuf" */
-    int opt_flags                          /* OPT_LOCAL, OPT_GLOBAL and
-                                           OPT_MODELINE */
-)
+/// Set the value of a number option, taking care of side effects
+///
+/// @param[in]  opt_idx  Option index in options[] table.
+/// @param[out]  varp  Pointer to the option variable.
+/// @param[in]  value  New value.
+/// @param  errbuf  Buffer for error messages.
+/// @param[in]  errbuflen  Length of `errbuf`.
+/// @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_u *errbuf, size_t errbuflen, int opt_flags)
 {
   char_u      *errmsg = NULL;
   long old_value = *(long *)varp;
@@ -3981,7 +3989,7 @@ set_num_option (
   /* Disallow changing some options from secure mode. */
   if ((secure || sandbox != 0)
       && (options[opt_idx].flags & P_SECURE)) {
-    return e_secure;
+    return (char *)e_secure;
   }
 
   *pp = value;
@@ -4251,8 +4259,9 @@ set_num_option (
         cmdline_row = (int)(Rows - p_ch);
       }
     }
-    if (p_window >= Rows || !option_was_set((char_u *)"window"))
+    if (p_window >= Rows || !option_was_set("window")) {
       p_window = Rows - 1;
+    }
   }
 
   if (curbuf->b_p_ts <= 0) {
@@ -4357,7 +4366,7 @@ set_num_option (
     curwin->w_set_curswant = TRUE;
   check_redraw(options[opt_idx].flags);
 
-  return errmsg;
+  return (char *)errmsg;
 }
 
 /*
@@ -4395,39 +4404,36 @@ static void check_redraw(uint32_t flags)
 /// @param[in]  len  Length of the option.
 ///
 /// @return Index of the option or -1 if option was not found.
-int findoption_len(const char_u *const arg, const size_t len)
+int findoption_len(const char *const arg, const size_t len)
 {
-  char *s, *p;
+  const char *s;
+  const char *p;
   static int quick_tab[27] = { 0, 0 };  // quick access table
-  int is_term_opt;
 
-  /*
-   * For first call: Initialize the quick-access table.
-   * It contains the index for the first option that starts with a certain
-   * letter.  There are 26 letters, plus the first "t_" option.
-   */
+  // For first call: Initialize the quick-access table.
+  // It contains the index for the first option that starts with a certain
+  // letter.  There are 26 letters, plus the first "t_" option.
   if (quick_tab[1] == 0) {
     p = options[0].fullname;
     for (short int i = 1; (s = options[i].fullname) != NULL; i++) {
       if (s[0] != p[0]) {
-        if (s[0] == 't' && s[1] == '_')
+        if (s[0] == 't' && s[1] == '_') {
           quick_tab[26] = i;
-        else
+        } else {
           quick_tab[CharOrdLow(s[0])] = i;
+        }
       }
       p = s;
     }
   }
 
-  /*
-   * Check for name starting with an illegal character.
-   */
+  // Check for name starting with an illegal character.
   if (len == 0 || arg[0] < 'a' || arg[0] > 'z') {
     return -1;
   }
 
   int opt_idx;
-  is_term_opt = (len > 2 && arg[0] == 't' && arg[1] == '_');
+  const bool is_term_opt = (len > 2 && arg[0] == 't' && arg[1] == '_');
   if (is_term_opt) {
     opt_idx = quick_tab[26];
   } else {
@@ -4435,7 +4441,7 @@ int findoption_len(const char_u *const arg, const size_t len)
   }
   // Match full name
   for (; (s = options[opt_idx].fullname) != NULL; opt_idx++) {
-    if (STRNCMP(arg, s, len) == 0 && s[len] == NUL) {
+    if (strncmp(arg, s, len) == 0 && s[len] == NUL) {
       break;
     }
   }
@@ -4444,20 +4450,22 @@ int findoption_len(const char_u *const arg, const size_t len)
     // Match short name
     for (; options[opt_idx].fullname != NULL; opt_idx++) {
       s = options[opt_idx].shortname;
-      if (s != NULL && STRNCMP(arg, s, len) == 0 && s[len] == NUL) {
+      if (s != NULL && strncmp(arg, s, len) == 0 && s[len] == NUL) {
         break;
       }
       s = NULL;
     }
   }
-  if (s == NULL)
+  if (s == NULL) {
     opt_idx = -1;
+  }
   return opt_idx;
 }
 
-bool is_tty_option(char *name)
+bool is_tty_option(const char *name)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  return (name[0] == 't' && name[1] == '_') || !strcmp((char *)name, "term");
+  return (name[0] == 't' && name[1] == '_') || strcmp(name, "term") == 0;
 }
 
 #define TCO_BUFFER_SIZE 8
@@ -4493,7 +4501,7 @@ bool get_tty_option(char *name, char **value)
   return false;
 }
 
-bool set_tty_option(char *name, char *value)
+bool set_tty_option(const char *name, const char *value)
 {
   if (!strcmp(name, "t_Co")) {
     int colors = atoi(value);
@@ -4504,23 +4512,24 @@ bool set_tty_option(char *name, char *value)
     if (colors != t_colors) {
       t_colors = colors;
       // We now have a different color setup, initialize it again.
-      init_highlight(TRUE, FALSE);
+      init_highlight(true, false);
     }
 
     return true;
   }
 
-  return is_tty_option(name) || !strcmp(name, "term")
-    || !strcmp(name, "ttytype");
+  return (is_tty_option(name) || !strcmp(name, "term")
+          || !strcmp(name, "ttytype"));
 }
 
-/*
- * Find index for option 'arg'.
- * Return -1 if not found.
- */
-static int findoption(char_u *arg)
+/// Find index for an option
+///
+/// @param[in]  arg  Option name.
+///
+/// @return Option index or -1 if option was not found.
+static int findoption(const char *const arg)
 {
-  return findoption_len(arg, STRLEN(arg));
+  return findoption_len(arg, strlen(arg));
 }
 
 /*
@@ -4548,9 +4557,10 @@ get_option_value (
   int opt_idx;
   char_u      *varp;
 
-  opt_idx = findoption(name);
-  if (opt_idx < 0)                  /* unknown option */
+  opt_idx = findoption((const char *)name);
+  if (opt_idx < 0) {  // Unknown option.
     return -3;
+  }
 
   varp = get_varp_scope(&(options[opt_idx]), opt_flags);
 
@@ -4608,7 +4618,7 @@ int get_option_value_strict(char *name,
   char_u *varp = NULL;
   vimoption_T *p;
   int rv = 0;
-  int opt_idx = findoption((uint8_t *)name);
+  int opt_idx = findoption(name);
   if (opt_idx < 0) {
     return 0;
   }
@@ -4702,21 +4712,19 @@ int get_option_value_strict(char *name,
   return rv;
 }
 
-/*
- * Set the value of option "name".
- * Use "string" for string options, use "number" for other options.
- *
- * Returns NULL on success or error message on error.
- */
-char_u *
-set_option_value (
-    char_u *name,
-    long number,
-    char_u *string,
-    int opt_flags                  /* OPT_LOCAL or 0 (both) */
-)
+/// Set the value of an option
+///
+/// @param[in]  name  Option name.
+/// @param[in]  number  New value for the number or boolean option.
+/// @param[in]  string  New value for string option.
+/// @param[in]  opt_flags  Flags: OPT_LOCAL or 0 (both).
+///
+/// @return NULL on success, error message on error.
+char *set_option_value(const char *const name, const long number,
+                       const char *const string, const int opt_flags)
+  FUNC_ATTR_NONNULL_ARG(1)
 {
-  if (set_tty_option((char *)name, (char *)string)) {
+  if (set_tty_option(name, string)) {
     return NULL;
   }
 
@@ -4724,9 +4732,9 @@ set_option_value (
   char_u      *varp;
 
   opt_idx = findoption(name);
-  if (opt_idx < 0)
+  if (opt_idx < 0) {
     EMSG2(_("E355: Unknown option: %s"), name);
-  else {
+  } else {
     uint32_t flags = options[opt_idx].flags;
     // Disallow changing some options in the sandbox
     if (sandbox > 0 && (flags & P_SECURE)) {
@@ -4734,11 +4742,11 @@ set_option_value (
       return NULL;
     }
     if (flags & P_STRING) {
-      const char *s = (const char *)string;
+      const char *s = string;
       if (s == NULL) {
         s = "";
       }
-      return (char_u *)set_string_option(opt_idx, s, opt_flags);
+      return set_string_option(opt_idx, s, opt_flags);
     } else {
       varp = get_varp_scope(&(options[opt_idx]), opt_flags);
       if (varp != NULL) {       /* hidden option is not changed */
@@ -4757,12 +4765,11 @@ set_option_value (
             return NULL;  // do nothing as we hit an error
           }
         }
-        if (flags & P_NUM)
-          return set_num_option(opt_idx, varp, number,
-              NULL, 0, opt_flags);
-        else
-          return set_bool_option(opt_idx, varp, (int)number,
-              opt_flags);
+        if (flags & P_NUM) {
+          return set_num_option(opt_idx, varp, number, NULL, 0, opt_flags);
+        } else {
+          return set_bool_option(opt_idx, varp, (int)number, opt_flags);
+        }
       }
     }
   }
@@ -4773,9 +4780,10 @@ char_u *get_highlight_default(void)
 {
   int i;
 
-  i = findoption((char_u *)"hl");
-  if (i >= 0)
+  i = findoption("hl");
+  if (i >= 0) {
     return options[i].def_val[VI_DEFAULT];
+  }
   return (char_u *)NULL;
 }
 
@@ -5212,7 +5220,7 @@ void unset_global_local_option(char *name, void *from)
   vimoption_T *p;
   buf_T *buf = (buf_T *)from;
 
-  int opt_idx = findoption((uint8_t *)name);
+  int opt_idx = findoption(name);
   if (opt_idx < 0) {
     EMSG2(_("E355: Unknown option: %s"), name);
     return;
@@ -5775,11 +5783,12 @@ void reset_modifiable(void)
 {
   int opt_idx;
 
-  curbuf->b_p_ma = FALSE;
-  p_ma = FALSE;
-  opt_idx = findoption((char_u *)"ma");
-  if (opt_idx >= 0)
-    options[opt_idx].def_val[VI_DEFAULT] = FALSE;
+  curbuf->b_p_ma = false;
+  p_ma = false;
+  opt_idx = findoption("ma");
+  if (opt_idx >= 0) {
+    options[opt_idx].def_val[VI_DEFAULT] = false;
+  }
 }
 
 /*
@@ -5877,15 +5886,15 @@ set_context_in_set_cmd (
       expand_option_name[2] = p[-2];
       expand_option_name[3] = p[-1];
     } else {
-      /* Allow * wildcard */
-      while (ASCII_ISALNUM(*p) || *p == '_' || *p == '*')
+      // Allow * wildcard.
+      while (ASCII_ISALNUM(*p) || *p == '_' || *p == '*') {
         p++;
-      if (*p == NUL)
+      }
+      if (*p == NUL) {
         return;
+      }
       nextchar = *p;
-      *p = NUL;
-      opt_idx = findoption(arg);
-      *p = nextchar;
+      opt_idx = findoption_len((const char *)arg, (size_t)(p - arg));
       if (opt_idx == -1 || options[opt_idx].var == NULL) {
         xp->xp_context = EXPAND_NOTHING;
         return;
@@ -6047,7 +6056,7 @@ void ExpandOldSetting(int *num_file, char_u ***file)
    * For a terminal key code expand_option_idx is < 0.
    */
   if (expand_option_idx < 0) {
-    expand_option_idx = findoption(expand_option_name);
+    expand_option_idx = findoption((const char *)expand_option_name);
   }
 
   if (expand_option_idx >= 0) {
@@ -6447,20 +6456,22 @@ void vimrc_found(char_u *fname, char_u *envname)
   }
 }
 
-/*
- * Return TRUE when option "name" has been set.
- * Only works correctly for global options.
- */
-int option_was_set(char_u *name)
+/// Check whether global option has been set
+///
+/// @param[in]  name  Option name.
+///
+/// @return True if it was set.
+static bool option_was_set(const char *name)
 {
   int idx;
 
   idx = findoption(name);
-  if (idx < 0)          /* unknown option */
-    return FALSE;
-  if (options[idx].flags & P_WAS_SET)
-    return TRUE;
-  return FALSE;
+  if (idx < 0) {  // Unknown option.
+    return false;
+  } else if (options[idx].flags & P_WAS_SET) {
+    return true;
+  }
+  return false;
 }
 
 /*
@@ -6945,10 +6956,11 @@ bool signcolumn_on(win_T *wp)
     return wp->w_buffer->b_signlist != NULL;
 }
 
-/// Get window or buffer local options.
-dict_T * get_winbuf_options(int bufopt)
+/// Get window or buffer local options
+dict_T *get_winbuf_options(const int bufopt)
+  FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC
 {
-  dict_T *d = dict_alloc();
+  dict_T *const d = tv_dict_alloc();
 
   for (int opt_idx = 0; options[opt_idx].fullname; opt_idx++) {
     struct vimoption *opt = &options[opt_idx];
diff --git a/src/nvim/path.c b/src/nvim/path.c
index dfcafc85de..2bd87b608e 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -282,48 +282,63 @@ bool dir_of_file_exists(char_u *fname)
   return retval;
 }
 
-/*
- * Versions of fnamecmp() and fnamencmp() that handle '/' and '\' equally
- * and deal with 'fileignorecase'.
- */
-int vim_fnamecmp(char_u *x, char_u *y)
+/// Compare two file names
+///
+/// Handles '/' and '\\' correctly and deals with &fileignorecase option.
+///
+/// @param[in]  fname1  First file name.
+/// @param[in]  fname2  Second file name.
+///
+/// @return 0 if they are equal, non-zero otherwise.
+int path_fnamecmp(const char *fname1, const char *fname2)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
 #ifdef BACKSLASH_IN_FILENAME
-  return vim_fnamencmp(x, y, MAXPATHL);
+  const size_t len1 = strlen(fname1);
+  const size_t len2 = strlen(fname2);
+  return path_fnamencmp(fname1, fname2, MAX(len1, len2));
 #else
-  if (p_fic)
-    return mb_stricmp(x, y);
-  return STRCMP(x, y);
+  return mb_strcmp_ic((bool)p_fic, fname1, fname2);
 #endif
 }
 
-int vim_fnamencmp(char_u *x, char_u *y, size_t len)
+/// Compare two file names
+///
+/// Handles '/' and '\\' correctly and deals with &fileignorecase option.
+///
+/// @param[in]  fname1  First file name.
+/// @param[in]  fname2  Second file name.
+/// @param[in]  len  Compare at most len bytes.
+///
+/// @return 0 if they are equal, non-zero otherwise.
+int path_fnamencmp(const char *const fname1, const char *const fname2,
+                   const size_t len)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
 #ifdef BACKSLASH_IN_FILENAME
-  char_u      *px = x;
-  char_u      *py = y;
-  int cx = NUL;
-  int cy = NUL;
+  int c1 = NUL;
+  int c2 = NUL;
 
+  const char *p1 = fname1;
+  const char *p2 = fname2;
   while (len > 0) {
-    cx = PTR2CHAR(px);
-    cy = PTR2CHAR(py);
-    if (cx == NUL || cy == NUL
-        || ((p_fic ? vim_tolower(cx) != vim_tolower(cy) : cx != cy)
-            && !(cx == '/' && cy == '\\')
-            && !(cx == '\\' && cy == '/')))
+    c1 = PTR2CHAR(p1);
+    c2 = PTR2CHAR(p2);
+    if (c1 == NUL || c2 == NUL
+        || (!((c1 == '/' || c1 == '\\') && (c2 == '\\' || c2 == '/')))
+        || (p_fic ? (c1 != c2 && CH_FOLD(c1) != CH_FOLD(c2)) : c1 != c2)) {
       break;
-    len -= MB_PTR2LEN(px);
-    px += MB_PTR2LEN(px);
-    py += MB_PTR2LEN(py);
+    }
+    len -= MB_PTR2LEN(p1);
+    p1 += MB_PTR2LEN(p1);
+    p2 += MB_PTR2LEN(p2);
   }
-  if (len == 0)
-    return 0;
-  return cx - cy;
+  return c1 - c2;
 #else
-  if (p_fic)
-    return mb_strnicmp(x, y, len);
-  return STRNCMP(x, y, len);
+  if (p_fic) {
+    return mb_strnicmp((const char_u *)fname1, (const char_u *)fname2, len);
+  }
+  return strncmp(fname1, fname2, len);
 #endif
 }
 
diff --git a/src/nvim/popupmnu.c b/src/nvim/popupmnu.c
index ea00afbd86..6346951c05 100644
--- a/src/nvim/popupmnu.c
+++ b/src/nvim/popupmnu.c
@@ -610,13 +610,10 @@ static int pum_set_selected(int n, int repeat)
           if (res == OK) {
             // Edit a new, empty buffer. Set options for a "wipeout"
             // buffer.
-            set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
-            set_option_value((char_u *)"bt", 0L,
-                             (char_u *)"nofile", OPT_LOCAL);
-            set_option_value((char_u *)"bh", 0L,
-                             (char_u *)"wipe", OPT_LOCAL);
-            set_option_value((char_u *)"diff", 0L,
-                             NULL, OPT_LOCAL);
+            set_option_value("swf", 0L, NULL, OPT_LOCAL);
+            set_option_value("bt", 0L, "nofile", OPT_LOCAL);
+            set_option_value("bh", 0L, "wipe", OPT_LOCAL);
+            set_option_value("diff", 0L, NULL, OPT_LOCAL);
           }
         }
 
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 323503c4f5..d23059ff22 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1236,7 +1236,7 @@ static int qf_add_entry(qf_info_T *qi, char_u *dir, char_u *fname, int bufnum,
   qfp->qf_nr = nr;
   if (type != 1 && !vim_isprintc(type))   /* only printable chars allowed */
     type = 0;
-  qfp->qf_type = type;
+  qfp->qf_type = (char_u)type;
   qfp->qf_valid = valid;
 
   lastp = &qi->qf_lists[qi->qf_curlist].qf_last;
@@ -2581,15 +2581,13 @@ void ex_copen(exarg_T *eap)
     else {
       /* Create a new quickfix buffer */
       (void)do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, oldwin);
-      /* switch off 'swapfile' */
-      set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
-      set_option_value((char_u *)"bt", 0L, (char_u *)"quickfix",
-          OPT_LOCAL);
-      set_option_value((char_u *)"bh", 0L, (char_u *)"wipe", OPT_LOCAL);
+      // Switch off 'swapfile'.
+      set_option_value("swf", 0L, NULL, OPT_LOCAL);
+      set_option_value("bt", 0L, "quickfix", OPT_LOCAL);
+      set_option_value("bh", 0L, "wipe", OPT_LOCAL);
       RESET_BINDING(curwin);
-      curwin->w_p_diff = FALSE;
-      set_option_value((char_u *)"fdm", 0L, (char_u *)"manual",
-          OPT_LOCAL);
+      curwin->w_p_diff = false;
+      set_option_value("fdm", 0L, "manual", OPT_LOCAL);
     }
 
     /* Only set the height when still in the same tab page and there is no
@@ -2901,14 +2899,14 @@ static void qf_fill_buffer(qf_info_T *qi, buf_T *buf, qfline_T *old_last)
     }
   }
 
-  /* correct cursor position */
-  check_lnums(TRUE);
+  // Correct cursor position.
+  check_lnums(true);
 
   if (old_last == NULL) {
     // Set the 'filetype' to "qf" each time after filling the buffer.  This
     // resembles reading a file into a buffer, it's more logical when using
     // autocommands.
-    set_option_value((char_u *)"ft", 0L, (char_u *)"qf", OPT_LOCAL);
+    set_option_value("ft", 0L, "qf", OPT_LOCAL);
     curbuf->b_p_ma = false;
 
     keep_filetype = true;                 // don't detect 'filetype'
@@ -4002,7 +4000,7 @@ int get_errorlist(win_T *wp, int qf_idx, list_T *list)
     if (bufnum != 0 && (buflist_findnr(bufnum) == NULL))
       bufnum = 0;
 
-    dict = dict_alloc();
+    dict = tv_dict_alloc();
     tv_list_append_dict(list, dict);
 
     buf[0] = qfp->qf_type;
@@ -4057,7 +4055,7 @@ int get_errorlist_properties(win_T *wp, dict_T *what, dict_T *retdict)
   int flags = QF_GETLIST_NONE;
 
   int qf_idx = qi->qf_curlist;  // default is the current list
-  if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) {
+  if ((di = tv_dict_find(what, S_LEN("nr"))) != NULL) {
     // Use the specified quickfix/location list
     if (di->di_tv.v_type == VAR_NUMBER) {
       qf_idx = di->di_tv.vval.v_number - 1;
@@ -4070,15 +4068,15 @@ int get_errorlist_properties(win_T *wp, dict_T *what, dict_T *retdict)
     }
   }
 
-  if (dict_find(what, (char_u *)"all", -1) != NULL) {
+  if (tv_dict_find(what, S_LEN("all")) != NULL) {
     flags |= QF_GETLIST_ALL;
   }
 
-  if (dict_find(what, (char_u *)"title", -1) != NULL) {
+  if (tv_dict_find(what, S_LEN("title")) != NULL) {
     flags |= QF_GETLIST_TITLE;
   }
 
-  if (dict_find(what, (char_u *)"winid", -1) != NULL) {
+  if (tv_dict_find(what, S_LEN("winid")) != NULL) {
     flags |= QF_GETLIST_WINID;
   }
 
@@ -4132,17 +4130,18 @@ static int qf_add_entries(qf_info_T *qi, list_T *list, char_u *title,
     if (d == NULL)
       continue;
 
-    char_u *filename = get_dict_string(d, "filename", true);
-    int bufnum = (int)get_dict_number(d, "bufnr");
-    long lnum = get_dict_number(d, "lnum");
-    int col = (int)get_dict_number(d, "col");
-    char_u vcol = (char_u)get_dict_number(d, "vcol");
-    int nr = (int)get_dict_number(d, "nr");
-    char_u *type = get_dict_string(d, "type", true);
-    char_u *pattern = get_dict_string(d, "pattern", true);
-    char_u *text = get_dict_string(d, "text", true);
+    char *const filename = tv_dict_get_string(d, "filename", true);
+    int bufnum = (int)tv_dict_get_number(d, "bufnr");
+    long lnum = tv_dict_get_number(d, "lnum");
+    int col = (int)tv_dict_get_number(d, "col");
+    char_u vcol = (char_u)tv_dict_get_number(d, "vcol");
+    int nr = (int)tv_dict_get_number(d, "nr");
+    const char *type_str = tv_dict_get_string(d, "type", false);
+    const char_u type = (char_u)(uint8_t)(type_str == NULL ? NUL : *type_str);
+    char *const pattern = tv_dict_get_string(d, "pattern", true);
+    char *text = tv_dict_get_string(d, "text", true);
     if (text == NULL) {
-      text = vim_strsave((char_u *)"");
+      text = xcalloc(1, 1);
     }
     bool valid = true;
     if ((filename == NULL && bufnum == 0) || (lnum == 0 && pattern == NULL)) {
@@ -4162,21 +4161,20 @@ static int qf_add_entries(qf_info_T *qi, list_T *list, char_u *title,
 
     int status = qf_add_entry(qi,
                               NULL,      // dir
-                              filename,
+                              (char_u *)filename,
                               bufnum,
-                              text,
+                              (char_u *)text,
                               lnum,
                               col,
                               vcol,      // vis_col
-                              pattern,   // search pattern
+                              (char_u *)pattern,   // search pattern
                               nr,
-                              (char_u)(type == NULL ? NUL : *type),
+                              type,
                               valid);
 
     xfree(filename);
     xfree(pattern);
     xfree(text);
-    xfree(type);
 
     if (status == FAIL) {
       retval = FAIL;
@@ -4213,7 +4211,7 @@ static int qf_set_properties(qf_info_T *qi, dict_T *what, int action)
     newlist = true;
   }
   int qf_idx = qi->qf_curlist;  // default is the current list
-  if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) {
+  if ((di = tv_dict_find(what, S_LEN("nr"))) != NULL) {
     // Use the specified quickfix/location list
     if (di->di_tv.v_type == VAR_NUMBER) {
       qf_idx = di->di_tv.vval.v_number - 1;
@@ -4231,10 +4229,11 @@ static int qf_set_properties(qf_info_T *qi, dict_T *what, int action)
     qf_idx = qi->qf_curlist;
   }
 
-  if ((di = dict_find(what, (char_u *)"title", -1)) != NULL) {
+  if ((di = tv_dict_find(what, S_LEN("title"))) != NULL) {
     if (di->di_tv.v_type == VAR_STRING) {
       xfree(qi->qf_lists[qf_idx].qf_title);
-      qi->qf_lists[qf_idx].qf_title = get_dict_string(what, "title", true);
+      qi->qf_lists[qf_idx].qf_title = (char_u *)tv_dict_get_string(
+          what, "title", true);
       if (qf_idx == qi->qf_curlist) {
         qf_update_win_titlevar(qi);
       }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 8c56eda7cf..fb9e820928 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -282,7 +282,7 @@ void restore_search_patterns(void)
 static inline void free_spat(struct spat *const spat)
 {
   xfree(spat->pat);
-  dict_unref(spat->additional_data);
+  tv_dict_unref(spat->additional_data);
 }
 
 #if defined(EXITFREE)
@@ -1290,10 +1290,11 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, int dir, char_u *pat)
      * ignored because we are interested in the next line -- Acevedo */
     if ((compl_cont_status & CONT_ADDING)
         && !(compl_cont_status & CONT_SOL)) {
-      if ((p_ic ? mb_stricmp(p, pat) : STRCMP(p, pat)) == 0)
+      if (mb_strcmp_ic((bool)p_ic, (const char *)p, (const char *)pat) == 0) {
         return OK;
-    } else if (*p != NUL) {   /* ignore empty lines */
-      /* expanding lines or words */
+      }
+    } else if (*p != NUL) {  // Ignore empty lines.
+      // Expanding lines or words.
       assert(compl_length >= 0);
       if ((p_ic ? mb_strnicmp(p, pat, (size_t)compl_length)
            : STRNCMP(p, pat, compl_length)) == 0)
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index c550cb0888..2fe042cda8 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1623,10 +1623,10 @@ static ShaDaWriteResult shada_pack_entry(msgpack_packer *const packer,
       for (const hashitem_T *hi= d->dv_hashtab.ht_array; todo; hi++) { \
         if (!HASHITEM_EMPTY(hi)) { \
           todo--; \
-          dictitem_T *const di = HI2DI(hi); \
-          const size_t key_len = strlen((const char *) hi->hi_key); \
+          dictitem_T *const di = TV_DICT_HI2DI(hi); \
+          const size_t key_len = strlen((const char *)hi->hi_key); \
           msgpack_pack_str(spacker, key_len); \
-          msgpack_pack_str_body(spacker, (const char *) hi->hi_key, key_len); \
+          msgpack_pack_str_body(spacker, (const char *)hi->hi_key, key_len); \
           if (encode_vim_to_msgpack(spacker, &di->di_tv, \
                                     _("additional data of ShaDa " what)) \
               == FAIL) { \
@@ -3156,17 +3156,17 @@ static void shada_free_shada_entry(ShadaEntry *const entry)
     case kSDItemJump:
     case kSDItemGlobalMark:
     case kSDItemLocalMark: {
-      dict_unref(entry->data.filemark.additional_data);
+      tv_dict_unref(entry->data.filemark.additional_data);
       xfree(entry->data.filemark.fname);
       break;
     }
     case kSDItemSearchPattern: {
-      dict_unref(entry->data.search_pattern.additional_data);
+      tv_dict_unref(entry->data.search_pattern.additional_data);
       xfree(entry->data.search_pattern.pat);
       break;
     }
     case kSDItemRegister: {
-      dict_unref(entry->data.reg.additional_data);
+      tv_dict_unref(entry->data.reg.additional_data);
       for (size_t i = 0; i < entry->data.reg.contents_size; i++) {
         xfree(entry->data.reg.contents[i]);
       }
@@ -3192,7 +3192,7 @@ static void shada_free_shada_entry(ShadaEntry *const entry)
     case kSDItemBufferList: {
       for (size_t i = 0; i < entry->data.buffer_list.size; i++) {
         xfree(entry->data.buffer_list.buffers[i].fname);
-        dict_unref(entry->data.buffer_list.buffers[i].additional_data);
+        tv_dict_unref(entry->data.buffer_list.buffers[i].additional_data);
       }
       xfree(entry->data.buffer_list.buffers);
       break;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 5ca5ab3339..56f0350aef 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -7134,16 +7134,17 @@ void ex_spelldump(exarg_T *eap)
   char_u  *spl;
   long dummy;
 
-  if (no_spell_checking(curwin))
+  if (no_spell_checking(curwin)) {
     return;
-  get_option_value((char_u*)"spl", &dummy, &spl, OPT_LOCAL);
+  }
+  get_option_value((char_u *)"spl", &dummy, &spl, OPT_LOCAL);
 
   // Create a new empty buffer in a new window.
   do_cmdline_cmd("new");
 
   // enable spelling locally in the new window
-  set_option_value((char_u*)"spell", true, (char_u*)"", OPT_LOCAL);
-  set_option_value((char_u*)"spl",  dummy, spl, OPT_LOCAL);
+  set_option_value("spell", true, "", OPT_LOCAL);
+  set_option_value("spl",  dummy, (char *)spl, OPT_LOCAL);
   xfree(spl);
 
   if (!bufempty()) {
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index c108ae4a2c..6ba2801203 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -5439,7 +5439,7 @@ static void init_spellfile(void)
             fname != NULL
             && strstr((char *)path_tail(fname), ".ascii.") != NULL
             ? (char_u *)"ascii" : spell_enc());
-        set_option_value((char_u *)"spellfile", 0L, buf, OPT_LOCAL);
+        set_option_value("spellfile", 0L, (const char *)buf, OPT_LOCAL);
         break;
       }
       aspath = false;
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 0a27d9dd92..632a5bf2a5 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -1406,14 +1406,14 @@ static int syn_stack_equal(synstate_T *sp)
         /* If the pointer is different it can still be the
          * same text.  Compare the strings, ignore case when
          * the start item has the sp_ic flag set. */
-        if (bsx->matches[j] == NULL
-            || six->matches[j] == NULL)
+        if (bsx->matches[j] == NULL || six->matches[j] == NULL) {
           break;
-        if ((SYN_ITEMS(syn_block)[CUR_STATE(i).si_idx]).sp_ic
-            ? mb_stricmp(bsx->matches[j],
-                six->matches[j]) != 0
-            : STRCMP(bsx->matches[j], six->matches[j]) != 0)
+        }
+        if (mb_strcmp_ic((SYN_ITEMS(syn_block)[CUR_STATE(i).si_idx]).sp_ic,
+                         (const char *)bsx->matches[j],
+                         (const char *)six->matches[j]) != 0) {
           break;
+        }
       }
     }
     if (j != NSUBEXP)
@@ -6510,16 +6510,16 @@ do_highlight (
               if (!ui_rgb_attached()) {
                 must_redraw = CLEAR;
                 if (color >= 0) {
-                  if (t_colors < 16)
+                  if (t_colors < 16) {
                     i = (color == 0 || color == 4);
-                  else
+                  } else {
                     i = (color < 7 || color == 8);
-                  /* Set the 'background' option if the value is
-                   * wrong. */
-                  if (i != (*p_bg == 'd'))
-                    set_option_value((char_u *)"bg", 0L,
-                        i ?  (char_u *)"dark"
-                        : (char_u *)"light", 0);
+                  }
+                  // Set the 'background' option if the value is
+                  // wrong.
+                  if (i != (*p_bg == 'd')) {
+                    set_option_value("bg", 0L, (i ? "dark" : "light"), 0);
+                  }
                 }
               }
             }
@@ -7113,7 +7113,7 @@ set_hl_attr (
  * Lookup a highlight group name and return it's ID.
  * If it is not found, 0 is returned.
  */
-int syn_name2id(char_u *name)
+int syn_name2id(const char_u *name)
 {
   int i;
   char_u name_u[200];
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index b0ffc12b5f..af19a1bfc4 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -773,7 +773,7 @@ do_tag (
             cmd[len] = NUL;
           }
 
-          dict = dict_alloc();
+          dict = tv_dict_alloc();
           tv_list_append_dict(list, dict);
 
           dict_add_nr_str(dict, "text", 0L, tag_name);
@@ -2768,8 +2768,8 @@ add_tag_field (
   int len = 0;
   int retval;
 
-  /* check that the field name doesn't exist yet */
-  if (dict_find(dict, (char_u *)field_name, -1) != NULL) {
+  // Check that the field name doesn't exist yet.
+  if (tv_dict_find(dict, field_name, -1) != NULL) {
     if (p_verbose > 0) {
       verbose_enter();
       smsg(_("Duplicate field name: %s"), field_name);
@@ -2824,7 +2824,7 @@ int get_tags(list_T *list, char_u *pat)
       if (STRNCMP(tp.tagname, "!_TAG_", 6) == 0)
         continue;
 
-      dict = dict_alloc();
+      dict = tv_dict_alloc();
       tv_list_append_dict(list, dict);
 
       full_fname = tag_full_fname(&tp);
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index c81e883fb9..85c4950b42 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -226,17 +226,17 @@ Terminal *terminal_open(TerminalOptions opts)
   rv->invalid_start = 0;
   rv->invalid_end = opts.height;
   refresh_screen(rv, curbuf);
-  set_option_value((uint8_t *)"buftype", 0, (uint8_t *)"terminal", OPT_LOCAL);
+  set_option_value("buftype", 0, "terminal", OPT_LOCAL);
 
   // Default settings for terminal buffers
   curbuf->b_p_ma = false;     // 'nomodifiable'
   curbuf->b_p_ul = -1;        // 'undolevels'
   curbuf->b_p_scbk = p_scbk;  // 'scrollback'
   curbuf->b_p_tw = 0;         // 'textwidth'
-  set_option_value((uint8_t *)"wrap", false, NULL, OPT_LOCAL);
-  set_option_value((uint8_t *)"number", false, NULL, OPT_LOCAL);
-  set_option_value((uint8_t *)"relativenumber", false, NULL, OPT_LOCAL);
-  set_option_value((uint8_t *)"list", false, NULL, OPT_LOCAL);
+  set_option_value("wrap", false, NULL, OPT_LOCAL);
+  set_option_value("number", false, NULL, OPT_LOCAL);
+  set_option_value("relativenumber", false, NULL, OPT_LOCAL);
+  set_option_value("list", false, NULL, OPT_LOCAL);
   buf_set_term_title(curbuf, (char *)curbuf->b_ffname);
   RESET_BINDING(curwin);
   // Reset cursor in current window.
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 729cf03e15..6e21dccebb 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -317,7 +317,7 @@ static long get_undolevel(void)
 static inline void zero_fmark_additional_data(fmark_T *fmarks)
 {
   for (size_t i = 0; i < NMARKS; i++) {
-    dict_unref(fmarks[i].additional_data);
+    tv_dict_unref(fmarks[i].additional_data);
     fmarks[i].additional_data = NULL;
   }
 }
@@ -2941,7 +2941,7 @@ void u_eval_tree(u_header_T *first_uhp, list_T *list)
   dict_T      *dict;
 
   while (uhp != NULL) {
-    dict = dict_alloc();
+    dict = tv_dict_alloc();
     dict_add_nr_str(dict, "seq", uhp->uh_seq, NULL);
     dict_add_nr_str(dict, "time", (long)uhp->uh_time, NULL);
     if (uhp == curbuf->b_u_newhead)
diff --git a/src/nvim/vim.h b/src/nvim/vim.h
index 87e9889465..ae654251f9 100644
--- a/src/nvim/vim.h
+++ b/src/nvim/vim.h
@@ -109,11 +109,14 @@ Error: configure did not run properly.Check auto/config.log.
 // all mode bits used for mapping
 #define MAP_ALL_MODES   (0x3f | SELECTMODE | TERM_FOCUS)
 
-/* directions */
-#define FORWARD                 1
-#define BACKWARD                (-1)
-#define FORWARD_FILE            3
-#define BACKWARD_FILE           (-3)
+/// Directions.
+typedef enum {
+  kDirectionNotSet = 0,
+  FORWARD = 1,
+  BACKWARD = (-1),
+  FORWARD_FILE = 3,
+  BACKWARD_FILE = (-3),
+} Direction;
 
 /* return values for functions */
 #if !(defined(OK) && (OK == 1))
@@ -282,15 +285,22 @@ enum {
 #define SHOWCMD_COLS 10                 /* columns needed by shown command */
 #define STL_MAX_ITEM 80                 /* max nr of %<flag> in statusline */
 
-/*
- * fnamecmp() is used to compare file names.
- * On some systems case in a file name does not matter, on others it does.
- * (this does not account for maximum name lengths and things like "../dir",
- * thus it is not 100% accurate!)
- */
-#define fnamecmp(x, y) vim_fnamecmp((char_u *)(x), (char_u *)(y))
-#define fnamencmp(x, y, n) vim_fnamencmp((char_u *)(x), (char_u *)(y), \
-    (size_t)(n))
+/// Compare file names
+///
+/// On some systems case in a file name does not matter, on others it does.
+///
+/// @note Does not account for maximum name lengths and things like "../dir",
+///       thus it is not 100% accurate. OS may also use different algorythm for
+///       case-insensitive comparison.
+///
+/// @param[in]  x  First file name to compare.
+/// @param[in]  y  Second file name to compare.
+///
+/// @return 0 for equal file names, non-zero otherwise.
+#define fnamecmp(x, y) path_fnamecmp((const char *)(x), (const char *)(y))
+#define fnamencmp(x, y, n) path_fnamencmp((const char *)(x), \
+                                          (const char *)(y), \
+                                          (size_t)(n))
 
 /*
  * Enums need a typecast to be used as array index (for Ultrix).
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 47a97da0cf..a3b0e6fc2d 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -2983,8 +2983,8 @@ static tabpage_T *alloc_tabpage(void)
   tp->handle = ++last_tp_handle;
   handle_register_tabpage(tp);
 
-  /* init t: variables */
-  tp->tp_vars = dict_alloc();
+  // Init t: variables.
+  tp->tp_vars = tv_dict_alloc();
   init_var_dict(tp->tp_vars, &tp->tp_winvar, VAR_SCOPE);
   tp->tp_diff_invalid = TRUE;
   tp->tp_ch_used = p_ch;
@@ -3811,8 +3811,8 @@ static win_T *win_alloc(win_T *after, int hidden)
   new_wp->handle = ++last_win_id;
   handle_register_window(new_wp);
 
-  /* init w: variables */
-  new_wp->w_vars = dict_alloc();
+  // Init w: variables.
+  new_wp->w_vars = tv_dict_alloc();
   init_var_dict(new_wp->w_vars, &new_wp->w_winvar, VAR_SCOPE);
 
   /* Don't execute autocommands while the window is not properly
@@ -5504,9 +5504,9 @@ void restore_buffer(bufref_T *save_curbuf)
 // Optionally, a desired ID 'id' can be specified (greater than or equal to 1).
 // If no particular ID is desired, -1 must be specified for 'id'.
 // Return ID of added match, -1 on failure.
-int match_add(win_T *wp, char_u *grp, char_u *pat,
+int match_add(win_T *wp, const char *const grp, const char *const pat,
               int prio, int id, list_T *pos_list,
-              char_u *conceal_char)
+              const char *const conceal_char)
 {
   matchitem_T *cur;
   matchitem_T *prev;
@@ -5534,11 +5534,11 @@ int match_add(win_T *wp, char_u *grp, char_u *pat,
       cur = cur->next;
     }
   }
-  if ((hlg_id = syn_namen2id(grp, (int)STRLEN(grp))) == 0) {
+  if ((hlg_id = syn_name2id((const char_u *)grp)) == 0) {
     EMSG2(_(e_nogroup), grp);
     return -1;
   }
-  if (pat != NULL && (regprog = vim_regcomp(pat, RE_MAGIC)) == NULL) {
+  if (pat != NULL && (regprog = vim_regcomp((char_u *)pat, RE_MAGIC)) == NULL) {
     EMSG2(_(e_invarg2), pat);
     return -1;
   }
@@ -5557,14 +5557,14 @@ int match_add(win_T *wp, char_u *grp, char_u *pat,
   m = xcalloc(1, sizeof(matchitem_T));
   m->id = id;
   m->priority = prio;
-  m->pattern = pat == NULL ? NULL: vim_strsave(pat);
+  m->pattern = pat == NULL ? NULL: (char_u *)xstrdup(pat);
   m->hlg_id = hlg_id;
   m->match.regprog = regprog;
   m->match.rmm_ic = FALSE;
   m->match.rmm_maxcol = 0;
   m->conceal_char = 0;
   if (conceal_char != NULL) {
-    m->conceal_char = (*mb_ptr2char)(conceal_char);
+    m->conceal_char = (*mb_ptr2char)((const char_u *)conceal_char);
   }
 
   // Set up position matches