vim-patch:8.1.1886: command line expansion code is spread out (#19861)

Problem:    Command line expansion code is spread out.
Solution:   Move the code to cmdexpand.c. (Yegappan Lakshmanan, closes vim/vim#4831)
https://github.com/vim/vim/commit/66b51420e0c8d49bcf6786b792c938d6099e3393

20 files changed, 1905 insertions, 1865 deletions

diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 7d8917cc73..0be83f0c05 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -10,6 +10,7 @@
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
 #include "nvim/eval.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_getln.h"
 #include "nvim/fileio.h"
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 1ff0140162..ab5b32bf3e 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -34,6 +34,7 @@
 #include "nvim/change.h"
 #include "nvim/channel.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cursor.h"
 #include "nvim/decoration.h"
 #include "nvim/diff.h"
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
new file mode 100644
index 0000000000..bf2ae1e16f
--- /dev/null
+++ b/src/nvim/cmdexpand.c
@@ -0,0 +1,1745 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+// cmdexpand.c: functions for command-line completion
+
+#include "nvim/api/private/helpers.h"
+#include "nvim/arglist.h"
+#include "nvim/ascii.h"
+#include "nvim/buffer.h"
+#include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
+#include "nvim/cmdhist.h"
+#include "nvim/eval.h"
+#include "nvim/eval/funcs.h"
+#include "nvim/eval/userfunc.h"
+#include "nvim/ex_cmds.h"
+#include "nvim/ex_cmds2.h"
+#include "nvim/ex_docmd.h"
+#include "nvim/ex_getln.h"
+#include "nvim/garray.h"
+#include "nvim/getchar.h"
+#include "nvim/help.h"
+#include "nvim/highlight_group.h"
+#include "nvim/if_cscope.h"
+#include "nvim/lua/executor.h"
+#include "nvim/mapping.h"
+#include "nvim/menu.h"
+#include "nvim/option.h"
+#include "nvim/os/os.h"
+#include "nvim/popupmenu.h"
+#include "nvim/profile.h"
+#include "nvim/regexp.h"
+#include "nvim/screen.h"
+#include "nvim/search.h"
+#include "nvim/sign.h"
+#include "nvim/strings.h"
+#include "nvim/syntax.h"
+#include "nvim/tag.h"
+#include "nvim/types.h"
+#include "nvim/ui.h"
+#include "nvim/usercmd.h"
+#include "nvim/vim.h"
+
+/// Type used by ExpandGeneric()
+typedef char *(*CompleteListItemGetter)(expand_T *, int);
+
+/// Type used by call_user_expand_func
+typedef void *(*user_expand_func_T)(const char_u *, int, typval_T *);
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "cmdexpand.c.generated.h"
+#endif
+
+static int cmd_showtail;  ///< Only show path tail in lists ?
+
+// TODO(zeertzjq): make these four variables static in cmdexpand.c
+
+/// "compl_match_array" points the currently displayed list of entries in the
+/// popup menu.  It is NULL when there is no popup menu.
+pumitem_T *compl_match_array = NULL;
+int compl_match_arraysize;
+/// First column in cmdline of the matched item for completion.
+int compl_startcol;
+int compl_selected;
+
+static int sort_func_compare(const void *s1, const void *s2)
+{
+  char_u *p1 = *(char_u **)s1;
+  char_u *p2 = *(char_u **)s2;
+
+  if (*p1 != '<' && *p2 == '<') {
+    return -1;
+  }
+  if (*p1 == '<' && *p2 != '<') {
+    return 1;
+  }
+  return STRCMP(p1, p2);
+}
+
+static void ExpandEscape(expand_T *xp, char_u *str, int numfiles, char **files, int options)
+{
+  int i;
+  char_u *p;
+  const int vse_what = xp->xp_context == EXPAND_BUFFERS ? VSE_BUFFER : VSE_NONE;
+
+  // May change home directory back to "~"
+  if (options & WILD_HOME_REPLACE) {
+    tilde_replace(str, numfiles, files);
+  }
+
+  if (options & WILD_ESCAPE) {
+    if (xp->xp_context == EXPAND_FILES
+        || xp->xp_context == EXPAND_FILES_IN_PATH
+        || xp->xp_context == EXPAND_SHELLCMD
+        || xp->xp_context == EXPAND_BUFFERS
+        || xp->xp_context == EXPAND_DIRECTORIES) {
+      // Insert a backslash into a file name before a space, \, %, #
+      // and wildmatch characters, except '~'.
+      for (i = 0; i < numfiles; i++) {
+        // for ":set path=" we need to escape spaces twice
+        if (xp->xp_backslash == XP_BS_THREE) {
+          p = vim_strsave_escaped((char_u *)files[i], (char_u *)" ");
+          xfree(files[i]);
+          files[i] = (char *)p;
+#if defined(BACKSLASH_IN_FILENAME)
+          p = vim_strsave_escaped(files[i], (char_u *)" ");
+          xfree(files[i]);
+          files[i] = p;
+#endif
+        }
+#ifdef BACKSLASH_IN_FILENAME
+        p = (char_u *)vim_strsave_fnameescape((const char *)files[i], vse_what);
+#else
+        p = (char_u *)vim_strsave_fnameescape((const char *)files[i],
+                                              xp->xp_shell ? VSE_SHELL : vse_what);
+#endif
+        xfree(files[i]);
+        files[i] = (char *)p;
+
+        // If 'str' starts with "\~", replace "~" at start of
+        // files[i] with "\~".
+        if (str[0] == '\\' && str[1] == '~' && files[i][0] == '~') {
+          escape_fname(&files[i]);
+        }
+      }
+      xp->xp_backslash = XP_BS_NONE;
+
+      // If the first file starts with a '+' escape it.  Otherwise it
+      // could be seen as "+cmd".
+      if (*files[0] == '+') {
+        escape_fname(&files[0]);
+      }
+    } else if (xp->xp_context == EXPAND_TAGS) {
+      // Insert a backslash before characters in a tag name that
+      // would terminate the ":tag" command.
+      for (i = 0; i < numfiles; i++) {
+        p = vim_strsave_escaped((char_u *)files[i], (char_u *)"\\|\"");
+        xfree(files[i]);
+        files[i] = (char *)p;
+      }
+    }
+  }
+}
+
+/// Return FAIL if this is not an appropriate context in which to do
+/// completion of anything, return OK if it is (even if there are no matches).
+/// For the caller, this means that the character is just passed through like a
+/// normal character (instead of being expanded).  This allows :s/^I^D etc.
+///
+/// @param options  extra options for ExpandOne()
+/// @param escape  if true, escape the returned matches
+int nextwild(expand_T *xp, int type, int options, bool escape)
+{
+  CmdlineInfo *const ccline = get_cmdline_info();
+  int i, j;
+  char_u *p1;
+  char_u *p2;
+  int difflen;
+
+  if (xp->xp_numfiles == -1) {
+    set_expand_context(xp);
+    cmd_showtail = expand_showtail(xp);
+  }
+
+  if (xp->xp_context == EXPAND_UNSUCCESSFUL) {
+    beep_flush();
+    return OK;      // Something illegal on command line
+  }
+  if (xp->xp_context == EXPAND_NOTHING) {
+    // Caller can use the character as a normal char instead
+    return FAIL;
+  }
+
+  if (!(ui_has(kUICmdline) || ui_has(kUIWildmenu))) {
+    msg_puts("...");  // show that we are busy
+    ui_flush();
+  }
+
+  i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
+  assert(ccline->cmdpos >= i);
+  xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
+
+  if (type == WILD_NEXT || type == WILD_PREV) {
+    // Get next/previous match for a previous expanded pattern.
+    p2 = ExpandOne(xp, NULL, NULL, 0, type);
+  } else {
+    // Translate string into pattern and expand it.
+    p1 = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
+    const int use_options = (options
+                             | WILD_HOME_REPLACE
+                             | WILD_ADD_SLASH
+                             | WILD_SILENT
+                             | (escape ? WILD_ESCAPE : 0)
+                             | (p_wic ? WILD_ICASE : 0));
+    p2 = ExpandOne(xp, p1, vim_strnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
+                   use_options, type);
+    xfree(p1);
+
+    // xp->xp_pattern might have been modified by ExpandOne (for example,
+    // in lua completion), so recompute the pattern index and length
+    i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
+    xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
+
+    // Longest match: make sure it is not shorter, happens with :help.
+    if (p2 != NULL && type == WILD_LONGEST) {
+      for (j = 0; (size_t)j < xp->xp_pattern_len; j++) {
+        if (ccline->cmdbuff[i + j] == '*'
+            || ccline->cmdbuff[i + j] == '?') {
+          break;
+        }
+      }
+      if ((int)STRLEN(p2) < j) {
+        XFREE_CLEAR(p2);
+      }
+    }
+  }
+
+  if (p2 != NULL && !got_int) {
+    difflen = (int)STRLEN(p2) - (int)(xp->xp_pattern_len);
+    if (ccline->cmdlen + difflen + 4 > ccline->cmdbufflen) {
+      realloc_cmdbuff(ccline->cmdlen + difflen + 4);
+      xp->xp_pattern = (char *)ccline->cmdbuff + i;
+    }
+    assert(ccline->cmdpos <= ccline->cmdlen);
+    memmove(&ccline->cmdbuff[ccline->cmdpos + difflen],
+            &ccline->cmdbuff[ccline->cmdpos],
+            (size_t)ccline->cmdlen - (size_t)ccline->cmdpos + 1);
+    memmove(&ccline->cmdbuff[i], p2, STRLEN(p2));
+    ccline->cmdlen += difflen;
+    ccline->cmdpos += difflen;
+  }
+  xfree(p2);
+
+  redrawcmd();
+  cursorcmd();
+
+  // When expanding a ":map" command and no matches are found, assume that
+  // the key is supposed to be inserted literally
+  if (xp->xp_context == EXPAND_MAPPINGS && p2 == NULL) {
+    return FAIL;
+  }
+
+  if (xp->xp_numfiles <= 0 && p2 == NULL) {
+    beep_flush();
+  } else if (xp->xp_numfiles == 1) {
+    // free expanded pattern
+    (void)ExpandOne(xp, NULL, NULL, 0, WILD_FREE);
+  }
+
+  return OK;
+}
+
+void cmdline_pum_display(bool changed_array)
+{
+  pum_display(compl_match_array, compl_match_arraysize, compl_selected,
+              changed_array, compl_startcol);
+}
+
+/// Do wildcard expansion on the string 'str'.
+/// Chars that should not be expanded must be preceded with a backslash.
+/// Return a pointer to allocated memory containing the new string.
+/// Return NULL for failure.
+///
+/// "orig" is the originally expanded string, copied to allocated memory.  It
+/// should either be kept in orig_save or freed.  When "mode" is WILD_NEXT or
+/// WILD_PREV "orig" should be NULL.
+///
+/// Results are cached in xp->xp_files and xp->xp_numfiles, except when "mode"
+/// is WILD_EXPAND_FREE or WILD_ALL.
+///
+/// mode = WILD_FREE:        just free previously expanded matches
+/// mode = WILD_EXPAND_FREE: normal expansion, do not keep matches
+/// mode = WILD_EXPAND_KEEP: normal expansion, keep matches
+/// mode = WILD_NEXT:        use next match in multiple match, wrap to first
+/// mode = WILD_PREV:        use previous match in multiple match, wrap to first
+/// mode = WILD_ALL:         return all matches concatenated
+/// mode = WILD_LONGEST:     return longest matched part
+/// mode = WILD_ALL_KEEP:    get all matches, keep matches
+///
+/// options = WILD_LIST_NOTFOUND:    list entries without a match
+/// options = WILD_HOME_REPLACE:     do home_replace() for buffer names
+/// options = WILD_USE_NL:           Use '\n' for WILD_ALL
+/// options = WILD_NO_BEEP:          Don't beep for multiple matches
+/// options = WILD_ADD_SLASH:        add a slash after directory names
+/// options = WILD_KEEP_ALL:         don't remove 'wildignore' entries
+/// options = WILD_SILENT:           don't print warning messages
+/// options = WILD_ESCAPE:           put backslash before special chars
+/// options = WILD_ICASE:            ignore case for files
+///
+/// The variables xp->xp_context and xp->xp_backslash must have been set!
+///
+/// @param orig  allocated copy of original of expanded string
+char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode)
+{
+  char_u *ss = NULL;
+  static int findex;
+  static char_u *orig_save = NULL;      // kept value of orig
+  int orig_saved = false;
+  int i;
+  int non_suf_match;                    // number without matching suffix
+
+  // first handle the case of using an old match
+  if (mode == WILD_NEXT || mode == WILD_PREV) {
+    if (xp->xp_numfiles > 0) {
+      if (mode == WILD_PREV) {
+        if (findex == -1) {
+          findex = xp->xp_numfiles;
+        }
+        findex--;
+      } else {  // mode == WILD_NEXT
+        findex++;
+      }
+
+      // When wrapping around, return the original string, set findex to
+      // -1.
+      if (findex < 0) {
+        if (orig_save == NULL) {
+          findex = xp->xp_numfiles - 1;
+        } else {
+          findex = -1;
+        }
+      }
+      if (findex >= xp->xp_numfiles) {
+        if (orig_save == NULL) {
+          findex = 0;
+        } else {
+          findex = -1;
+        }
+      }
+      if (compl_match_array) {
+        compl_selected = findex;
+        cmdline_pum_display(false);
+      } else if (p_wmnu) {
+        redraw_wildmenu(xp, xp->xp_numfiles, xp->xp_files, findex, cmd_showtail);
+      }
+      if (findex == -1) {
+        return vim_strsave(orig_save);
+      }
+      return vim_strsave((char_u *)xp->xp_files[findex]);
+    } else {
+      return NULL;
+    }
+  }
+
+  if (mode == WILD_CANCEL) {
+    ss = vim_strsave(orig_save ? orig_save : (char_u *)"");
+  } else if (mode == WILD_APPLY) {
+    ss =  vim_strsave(findex == -1 ? (orig_save ? orig_save : (char_u *)"") :
+                      (char_u *)xp->xp_files[findex]);
+  }
+
+  // free old names
+  if (xp->xp_numfiles != -1 && mode != WILD_ALL && mode != WILD_LONGEST) {
+    FreeWild(xp->xp_numfiles, xp->xp_files);
+    xp->xp_numfiles = -1;
+    XFREE_CLEAR(orig_save);
+  }
+  findex = 0;
+
+  if (mode == WILD_FREE) {      // only release file name
+    return NULL;
+  }
+
+  if (xp->xp_numfiles == -1 && mode != WILD_APPLY && mode != WILD_CANCEL) {
+    xfree(orig_save);
+    orig_save = orig;
+    orig_saved = true;
+
+    // Do the expansion.
+    if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
+#ifdef FNAME_ILLEGAL
+      // Illegal file name has been silently skipped.  But when there
+      // are wildcards, the real problem is that there was no match,
+      // causing the pattern to be added, which has illegal characters.
+      if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND)) {
+        semsg(_(e_nomatch2), str);
+      }
+#endif
+    } else if (xp->xp_numfiles == 0) {
+      if (!(options & WILD_SILENT)) {
+        semsg(_(e_nomatch2), str);
+      }
+    } else {
+      // Escape the matches for use on the command line.
+      ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
+
+      // Check for matching suffixes in file names.
+      if (mode != WILD_ALL && mode != WILD_ALL_KEEP
+          && mode != WILD_LONGEST) {
+        if (xp->xp_numfiles) {
+          non_suf_match = xp->xp_numfiles;
+        } else {
+          non_suf_match = 1;
+        }
+        if ((xp->xp_context == EXPAND_FILES
+             || xp->xp_context == EXPAND_DIRECTORIES)
+            && xp->xp_numfiles > 1) {
+          // More than one match; check suffix.
+          // The files will have been sorted on matching suffix in
+          // expand_wildcards, only need to check the first two.
+          non_suf_match = 0;
+          for (i = 0; i < 2; i++) {
+            if (match_suffix((char_u *)xp->xp_files[i])) {
+              non_suf_match++;
+            }
+          }
+        }
+        if (non_suf_match != 1) {
+          // Can we ever get here unless it's while expanding
+          // interactively?  If not, we can get rid of this all
+          // together. Don't really want to wait for this message
+          // (and possibly have to hit return to continue!).
+          if (!(options & WILD_SILENT)) {
+            emsg(_(e_toomany));
+          } else if (!(options & WILD_NO_BEEP)) {
+            beep_flush();
+          }
+        }
+        if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE)) {
+          ss = vim_strsave((char_u *)xp->xp_files[0]);
+        }
+      }
+    }
+  }
+
+  // Find longest common part
+  if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
+    size_t len = 0;
+
+    for (size_t mb_len; xp->xp_files[0][len]; len += mb_len) {
+      mb_len = (size_t)utfc_ptr2len(&xp->xp_files[0][len]);
+      int c0 = utf_ptr2char(&xp->xp_files[0][len]);
+      for (i = 1; i < xp->xp_numfiles; i++) {
+        int ci = utf_ptr2char(&xp->xp_files[i][len]);
+
+        if (p_fic && (xp->xp_context == EXPAND_DIRECTORIES
+                      || xp->xp_context == EXPAND_FILES
+                      || xp->xp_context == EXPAND_SHELLCMD
+                      || xp->xp_context == EXPAND_BUFFERS)) {
+          if (mb_tolower(c0) != mb_tolower(ci)) {
+            break;
+          }
+        } else if (c0 != ci) {
+          break;
+        }
+      }
+      if (i < xp->xp_numfiles) {
+        if (!(options & WILD_NO_BEEP)) {
+          vim_beep(BO_WILD);
+        }
+        break;
+      }
+    }
+
+    ss = (char_u *)xstrndup(xp->xp_files[0], len);
+    findex = -1;  // next p_wc gets first one
+  }
+
+  // Concatenate all matching names
+  // TODO(philix): use xstpcpy instead of strcat in a loop (ExpandOne)
+  if (mode == WILD_ALL && xp->xp_numfiles > 0) {
+    size_t len = 0;
+    for (i = 0; i < xp->xp_numfiles; i++) {
+      len += STRLEN(xp->xp_files[i]) + 1;
+    }
+    ss = xmalloc(len);
+    *ss = NUL;
+    for (i = 0; i < xp->xp_numfiles; i++) {
+      STRCAT(ss, xp->xp_files[i]);
+      if (i != xp->xp_numfiles - 1) {
+        STRCAT(ss, (options & WILD_USE_NL) ? "\n" : " ");
+      }
+    }
+  }
+
+  if (mode == WILD_EXPAND_FREE || mode == WILD_ALL) {
+    ExpandCleanup(xp);
+  }
+
+  // Free "orig" if it wasn't stored in "orig_save".
+  if (!orig_saved) {
+    xfree(orig);
+  }
+
+  return ss;
+}
+
+/// Prepare an expand structure for use.
+void ExpandInit(expand_T *xp)
+  FUNC_ATTR_NONNULL_ALL
+{
+  CLEAR_POINTER(xp);
+  xp->xp_backslash = XP_BS_NONE;
+  xp->xp_numfiles = -1;
+}
+
+/// Cleanup an expand structure after use.
+void ExpandCleanup(expand_T *xp)
+{
+  if (xp->xp_numfiles >= 0) {
+    FreeWild(xp->xp_numfiles, xp->xp_files);
+    xp->xp_numfiles = -1;
+  }
+}
+
+/// Show all matches for completion on the command line.
+/// Returns EXPAND_NOTHING when the character that triggered expansion should
+/// be inserted like a normal character.
+int showmatches(expand_T *xp, int wildmenu)
+{
+  CmdlineInfo *const ccline = get_cmdline_info();
+#define L_SHOWFILE(m) (showtail \
+                       ? sm_gettail(files_found[m], false) : files_found[m])
+  int num_files;
+  char **files_found;
+  int i, j, k;
+  int maxlen;
+  int lines;
+  int columns;
+  char_u *p;
+  int lastlen;
+  int attr;
+  int showtail;
+
+  if (xp->xp_numfiles == -1) {
+    set_expand_context(xp);
+    i = expand_cmdline(xp, ccline->cmdbuff, ccline->cmdpos,
+                       &num_files, &files_found);
+    showtail = expand_showtail(xp);
+    if (i != EXPAND_OK) {
+      return i;
+    }
+  } else {
+    num_files = xp->xp_numfiles;
+    files_found = xp->xp_files;
+    showtail = cmd_showtail;
+  }
+
+  bool compl_use_pum = (ui_has(kUICmdline)
+                        ? ui_has(kUIPopupmenu)
+                        : wildmenu && (wop_flags & WOP_PUM))
+                       || ui_has(kUIWildmenu);
+
+  if (compl_use_pum) {
+    assert(num_files >= 0);
+    compl_match_arraysize = num_files;
+    compl_match_array = xcalloc((size_t)compl_match_arraysize,
+                                sizeof(pumitem_T));
+    for (i = 0; i < num_files; i++) {
+      compl_match_array[i].pum_text = (char_u *)L_SHOWFILE(i);
+    }
+    char_u *endpos = (char_u *)(showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
+    if (ui_has(kUICmdline)) {
+      compl_startcol = (int)(endpos - ccline->cmdbuff);
+    } else {
+      compl_startcol = cmd_screencol((int)(endpos - ccline->cmdbuff));
+    }
+    compl_selected = -1;
+    cmdline_pum_display(true);
+    return EXPAND_OK;
+  }
+
+  if (!wildmenu) {
+    msg_didany = false;                 // lines_left will be set
+    msg_start();                        // prepare for paging
+    msg_putchar('\n');
+    ui_flush();
+    cmdline_row = msg_row;
+    msg_didany = false;                 // lines_left will be set again
+    msg_start();                        // prepare for paging
+  }
+
+  if (got_int) {
+    got_int = false;            // only int. the completion, not the cmd line
+  } else if (wildmenu) {
+    redraw_wildmenu(xp, num_files, files_found, -1, showtail);
+  } else {
+    // find the length of the longest file name
+    maxlen = 0;
+    for (i = 0; i < num_files; i++) {
+      if (!showtail && (xp->xp_context == EXPAND_FILES
+                        || xp->xp_context == EXPAND_SHELLCMD
+                        || xp->xp_context == EXPAND_BUFFERS)) {
+        home_replace(NULL, files_found[i], (char *)NameBuff, MAXPATHL, true);
+        j = vim_strsize((char *)NameBuff);
+      } else {
+        j = vim_strsize(L_SHOWFILE(i));
+      }
+      if (j > maxlen) {
+        maxlen = j;
+      }
+    }
+
+    if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
+      lines = num_files;
+    } else {
+      // compute the number of columns and lines for the listing
+      maxlen += 2;          // two spaces between file names
+      columns = (Columns + 2) / maxlen;
+      if (columns < 1) {
+        columns = 1;
+      }
+      lines = (num_files + columns - 1) / columns;
+    }
+
+    attr = HL_ATTR(HLF_D);      // find out highlighting for directories
+
+    if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
+      msg_puts_attr(_("tagname"), HL_ATTR(HLF_T));
+      msg_clr_eos();
+      msg_advance(maxlen - 3);
+      msg_puts_attr(_(" kind file\n"), HL_ATTR(HLF_T));
+    }
+
+    // list the files line by line
+    for (i = 0; i < lines; i++) {
+      lastlen = 999;
+      for (k = i; k < num_files; k += lines) {
+        if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
+          msg_outtrans_attr((char_u *)files_found[k], HL_ATTR(HLF_D));
+          p = (char_u *)files_found[k] + STRLEN(files_found[k]) + 1;
+          msg_advance(maxlen + 1);
+          msg_puts((const char *)p);
+          msg_advance(maxlen + 3);
+          msg_outtrans_long_attr(p + 2, HL_ATTR(HLF_D));
+          break;
+        }
+        for (j = maxlen - lastlen; --j >= 0;) {
+          msg_putchar(' ');
+        }
+        if (xp->xp_context == EXPAND_FILES
+            || xp->xp_context == EXPAND_SHELLCMD
+            || xp->xp_context == EXPAND_BUFFERS) {
+          // highlight directories
+          if (xp->xp_numfiles != -1) {
+            // Expansion was done before and special characters
+            // were escaped, need to halve backslashes.  Also
+            // $HOME has been replaced with ~/.
+            char_u *exp_path = expand_env_save_opt((char_u *)files_found[k], true);
+            char_u *path = exp_path != NULL ? exp_path : (char_u *)files_found[k];
+            char_u *halved_slash = backslash_halve_save(path);
+            j = os_isdir(halved_slash);
+            xfree(exp_path);
+            if (halved_slash != path) {
+              xfree(halved_slash);
+            }
+          } else {
+            // Expansion was done here, file names are literal.
+            j = os_isdir((char_u *)files_found[k]);
+          }
+          if (showtail) {
+            p = (char_u *)L_SHOWFILE(k);
+          } else {
+            home_replace(NULL, files_found[k], (char *)NameBuff, MAXPATHL, true);
+            p = NameBuff;
+          }
+        } else {
+          j = false;
+          p = (char_u *)L_SHOWFILE(k);
+        }
+        lastlen = msg_outtrans_attr(p, j ? attr : 0);
+      }
+      if (msg_col > 0) {        // when not wrapped around
+        msg_clr_eos();
+        msg_putchar('\n');
+      }
+      ui_flush();                          // show one line at a time
+      if (got_int) {
+        got_int = false;
+        break;
+      }
+    }
+
+    // we redraw the command below the lines that we have just listed
+    // This is a bit tricky, but it saves a lot of screen updating.
+    cmdline_row = msg_row;      // will put it back later
+  }
+
+  if (xp->xp_numfiles == -1) {
+    FreeWild(num_files, files_found);
+  }
+
+  return EXPAND_OK;
+}
+
+/// Private path_tail for showmatches() (and redraw_wildmenu()):
+/// Find tail of file name path, but ignore trailing "/".
+char *sm_gettail(char *s, bool eager)
+{
+  char_u *p;
+  char_u *t = (char_u *)s;
+  bool had_sep = false;
+
+  for (p = (char_u *)s; *p != NUL;) {
+    if (vim_ispathsep(*p)
+#ifdef BACKSLASH_IN_FILENAME
+        && !rem_backslash(p)
+#endif
+        ) {
+      if (eager) {
+        t = p + 1;
+      } else {
+        had_sep = true;
+      }
+    } else if (had_sep) {
+      t = p;
+      had_sep = false;
+    }
+    MB_PTR_ADV(p);
+  }
+  return (char *)t;
+}
+
+/// Return true if we only need to show the tail of completion matches.
+/// When not completing file names or there is a wildcard in the path false is
+/// returned.
+static bool expand_showtail(expand_T *xp)
+{
+  char_u *s;
+  char_u *end;
+
+  // When not completing file names a "/" may mean something different.
+  if (xp->xp_context != EXPAND_FILES
+      && xp->xp_context != EXPAND_SHELLCMD
+      && xp->xp_context != EXPAND_DIRECTORIES) {
+    return false;
+  }
+
+  end = (char_u *)path_tail(xp->xp_pattern);
+  if (end == (char_u *)xp->xp_pattern) {          // there is no path separator
+    return false;
+  }
+
+  for (s = (char_u *)xp->xp_pattern; s < end; s++) {
+    // Skip escaped wildcards.  Only when the backslash is not a path
+    // separator, on DOS the '*' "path\*\file" must not be skipped.
+    if (rem_backslash(s)) {
+      s++;
+    } else if (vim_strchr("*?[", *s) != NULL) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/// Prepare a string for expansion.
+///
+/// When expanding file names: The string will be used with expand_wildcards().
+/// Copy "fname[len]" into allocated memory and add a '*' at the end.
+/// When expanding other names: The string will be used with regcomp().  Copy
+/// the name into allocated memory and prepend "^".
+///
+/// @param context EXPAND_FILES etc.
+char_u *addstar(char_u *fname, size_t len, int context)
+  FUNC_ATTR_NONNULL_RET
+{
+  char_u *retval;
+  size_t i, j;
+  size_t new_len;
+  char_u *tail;
+  int ends_in_star;
+
+  if (context != EXPAND_FILES
+      && context != EXPAND_FILES_IN_PATH
+      && context != EXPAND_SHELLCMD
+      && context != EXPAND_DIRECTORIES) {
+    // Matching will be done internally (on something other than files).
+    // So we convert the file-matching-type wildcards into our kind for
+    // use with vim_regcomp().  First work out how long it will be:
+
+    // For help tags the translation is done in find_help_tags().
+    // For a tag pattern starting with "/" no translation is needed.
+    if (context == EXPAND_HELP
+        || context == EXPAND_CHECKHEALTH
+        || context == EXPAND_COLORS
+        || context == EXPAND_COMPILER
+        || context == EXPAND_OWNSYNTAX
+        || context == EXPAND_FILETYPE
+        || context == EXPAND_PACKADD
+        || ((context == EXPAND_TAGS_LISTFILES || context == EXPAND_TAGS)
+            && fname[0] == '/')) {
+      retval = vim_strnsave(fname, len);
+    } else {
+      new_len = len + 2;                // +2 for '^' at start, NUL at end
+      for (i = 0; i < len; i++) {
+        if (fname[i] == '*' || fname[i] == '~') {
+          new_len++;                    // '*' needs to be replaced by ".*"
+                                        // '~' needs to be replaced by "\~"
+        }
+        // Buffer names are like file names.  "." should be literal
+        if (context == EXPAND_BUFFERS && fname[i] == '.') {
+          new_len++;                    // "." becomes "\."
+        }
+        // Custom expansion takes care of special things, match
+        // backslashes literally (perhaps also for other types?)
+        if ((context == EXPAND_USER_DEFINED
+             || context == EXPAND_USER_LIST) && fname[i] == '\\') {
+          new_len++;                    // '\' becomes "\\"
+        }
+      }
+      retval = xmalloc(new_len);
+      {
+        retval[0] = '^';
+        j = 1;
+        for (i = 0; i < len; i++, j++) {
+          // Skip backslash.  But why?  At least keep it for custom
+          // expansion.
+          if (context != EXPAND_USER_DEFINED
+              && context != EXPAND_USER_LIST
+              && fname[i] == '\\'
+              && ++i == len) {
+            break;
+          }
+
+          switch (fname[i]) {
+          case '*':
+            retval[j++] = '.';
+            break;
+          case '~':
+            retval[j++] = '\\';
+            break;
+          case '?':
+            retval[j] = '.';
+            continue;
+          case '.':
+            if (context == EXPAND_BUFFERS) {
+              retval[j++] = '\\';
+            }
+            break;
+          case '\\':
+            if (context == EXPAND_USER_DEFINED
+                || context == EXPAND_USER_LIST) {
+              retval[j++] = '\\';
+            }
+            break;
+          }
+          retval[j] = fname[i];
+        }
+        retval[j] = NUL;
+      }
+    }
+  } else {
+    retval = xmalloc(len + 4);
+    STRLCPY(retval, fname, len + 1);
+
+    // Don't add a star to *, ~, ~user, $var or `cmd`.
+    // * would become **, which walks the whole tree.
+    // ~ would be at the start of the file name, but not the tail.
+    // $ could be anywhere in the tail.
+    // ` could be anywhere in the file name.
+    // When the name ends in '$' don't add a star, remove the '$'.
+    tail = (char_u *)path_tail((char *)retval);
+    ends_in_star = (len > 0 && retval[len - 1] == '*');
+#ifndef BACKSLASH_IN_FILENAME
+    for (ssize_t k = (ssize_t)len - 2; k >= 0; k--) {
+      if (retval[k] != '\\') {
+        break;
+      }
+      ends_in_star = !ends_in_star;
+    }
+#endif
+    if ((*retval != '~' || tail != retval)
+        && !ends_in_star
+        && vim_strchr((char *)tail, '$') == NULL
+        && vim_strchr((char *)retval, '`') == NULL) {
+      retval[len++] = '*';
+    } else if (len > 0 && retval[len - 1] == '$') {
+      len--;
+    }
+    retval[len] = NUL;
+  }
+  return retval;
+}
+
+/// Must parse the command line so far to work out what context we are in.
+/// Completion can then be done based on that context.
+/// This routine sets the variables:
+///  xp->xp_pattern          The start of the pattern to be expanded within
+///                              the command line (ends at the cursor).
+///  xp->xp_context          The type of thing to expand.  Will be one of:
+///
+///  EXPAND_UNSUCCESSFUL     Used sometimes when there is something illegal on
+///                          the command line, like an unknown command.  Caller
+///                          should beep.
+///  EXPAND_NOTHING          Unrecognised context for completion, use char like
+///                          a normal char, rather than for completion.  eg
+///                          :s/^I/
+///  EXPAND_COMMANDS         Cursor is still touching the command, so complete
+///                          it.
+///  EXPAND_BUFFERS          Complete file names for :buf and :sbuf commands.
+///  EXPAND_FILES            After command with EX_XFILE set, or after setting
+///                          with P_EXPAND set.  eg :e ^I, :w>>^I
+///  EXPAND_DIRECTORIES      In some cases this is used instead of the latter
+///                          when we know only directories are of interest.  eg
+///                          :set dir=^I
+///  EXPAND_SHELLCMD         After ":!cmd", ":r !cmd"  or ":w !cmd".
+///  EXPAND_SETTINGS         Complete variable names.  eg :set d^I
+///  EXPAND_BOOL_SETTINGS    Complete boolean variables only,  eg :set no^I
+///  EXPAND_TAGS             Complete tags from the files in p_tags.  eg :ta a^I
+///  EXPAND_TAGS_LISTFILES   As above, but list filenames on ^D, after :tselect
+///  EXPAND_HELP             Complete tags from the file 'helpfile'/tags
+///  EXPAND_EVENTS           Complete event names
+///  EXPAND_SYNTAX           Complete :syntax command arguments
+///  EXPAND_HIGHLIGHT        Complete highlight (syntax) group names
+///  EXPAND_AUGROUP          Complete autocommand group names
+///  EXPAND_USER_VARS        Complete user defined variable names, eg :unlet a^I
+///  EXPAND_MAPPINGS         Complete mapping and abbreviation names,
+///                            eg :unmap a^I , :cunab x^I
+///  EXPAND_FUNCTIONS        Complete internal or user defined function names,
+///                            eg :call sub^I
+///  EXPAND_USER_FUNC        Complete user defined function names, eg :delf F^I
+///  EXPAND_EXPRESSION       Complete internal or user defined function/variable
+///                          names in expressions, eg :while s^I
+///  EXPAND_ENV_VARS         Complete environment variable names
+///  EXPAND_USER             Complete user names
+void set_expand_context(expand_T *xp)
+{
+  CmdlineInfo *const ccline = get_cmdline_info();
+
+  // only expansion for ':', '>' and '=' command-lines
+  if (ccline->cmdfirstc != ':'
+      && ccline->cmdfirstc != '>' && ccline->cmdfirstc != '='
+      && !ccline->input_fn) {
+    xp->xp_context = EXPAND_NOTHING;
+    return;
+  }
+  set_cmd_context(xp, ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
+}
+
+/// @param str  start of command line
+/// @param len  length of command line (excl. NUL)
+/// @param col  position of cursor
+/// @param use_ccline  use ccline for info
+void set_cmd_context(expand_T *xp, char_u *str, int len, int col, int use_ccline)
+{
+  CmdlineInfo *const ccline = get_cmdline_info();
+  char_u old_char = NUL;
+
+  // Avoid a UMR warning from Purify, only save the character if it has been
+  // written before.
+  if (col < len) {
+    old_char = str[col];
+  }
+  str[col] = NUL;
+  const char *nextcomm = (const char *)str;
+
+  if (use_ccline && ccline->cmdfirstc == '=') {
+    // pass CMD_SIZE because there is no real command
+    set_context_for_expression(xp, (char *)str, CMD_SIZE);
+  } else if (use_ccline && ccline->input_fn) {
+    xp->xp_context = ccline->xp_context;
+    xp->xp_pattern = (char *)ccline->cmdbuff;
+    xp->xp_arg = (char *)ccline->xp_arg;
+  } else {
+    while (nextcomm != NULL) {
+      nextcomm = set_one_cmd_context(xp, nextcomm);
+    }
+  }
+
+  // Store the string here so that call_user_expand_func() can get to them
+  // easily.
+  xp->xp_line = (char *)str;
+  xp->xp_col = col;
+
+  str[col] = old_char;
+}
+
+/// Expand the command line "str" from context "xp".
+/// "xp" must have been set by set_cmd_context().
+/// xp->xp_pattern points into "str", to where the text that is to be expanded
+/// starts.
+/// Returns EXPAND_UNSUCCESSFUL when there is something illegal before the
+/// cursor.
+/// Returns EXPAND_NOTHING when there is nothing to expand, might insert the
+/// key that triggered expansion literally.
+/// Returns EXPAND_OK otherwise.
+///
+/// @param str  start of command line
+/// @param col  position of cursor
+/// @param matchcount  return: nr of matches
+/// @param matches  return: array of pointers to matches
+int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***matches)
+{
+  char_u *file_str = NULL;
+  int options = WILD_ADD_SLASH|WILD_SILENT;
+
+  if (xp->xp_context == EXPAND_UNSUCCESSFUL) {
+    beep_flush();
+    return EXPAND_UNSUCCESSFUL;      // Something illegal on command line
+  }
+  if (xp->xp_context == EXPAND_NOTHING) {
+    // Caller can use the character as a normal char instead
+    return EXPAND_NOTHING;
+  }
+
+  // add star to file name, or convert to regexp if not exp. files.
+  assert((str + col) - (char_u *)xp->xp_pattern >= 0);
+  xp->xp_pattern_len = (size_t)((str + col) - (char_u *)xp->xp_pattern);
+  file_str = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
+
+  if (p_wic) {
+    options += WILD_ICASE;
+  }
+
+  // find all files that match the description
+  if (ExpandFromContext(xp, file_str, matchcount, matches, options) == FAIL) {
+    *matchcount = 0;
+    *matches = NULL;
+  }
+  xfree(file_str);
+
+  return EXPAND_OK;
+}
+
+/// Completion for |:checkhealth| command.
+///
+/// Given to ExpandGeneric() to obtain all available heathcheck names.
+/// @param[in] idx  Index of the healthcheck item.
+/// @param[in] xp  Not used.
+static char *get_healthcheck_names(expand_T *xp, int idx)
+{
+  static Object names = OBJECT_INIT;
+  static unsigned last_gen = 0;
+
+  if (last_gen != get_cmdline_last_prompt_id() || last_gen == 0) {
+    Array a = ARRAY_DICT_INIT;
+    Error err = ERROR_INIT;
+    Object res = nlua_exec(STATIC_CSTR_AS_STRING("return vim.health._complete()"), a, &err);
+    api_clear_error(&err);
+    api_free_object(names);
+    names = res;
+    last_gen = get_cmdline_last_prompt_id();
+  }
+
+  if (names.type == kObjectTypeArray && idx < (int)names.data.array.size) {
+    return names.data.array.items[idx].data.string.data;
+  }
+  return NULL;
+}
+
+typedef char *(*ExpandFunc)(expand_T *, int);
+
+/// Do the expansion based on xp->xp_context and "pat".
+///
+/// @param options  WILD_ flags
+static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***file, int options)
+{
+  regmatch_T regmatch;
+  int ret;
+  int flags;
+
+  flags = EW_DIR;       // include directories
+  if (options & WILD_LIST_NOTFOUND) {
+    flags |= EW_NOTFOUND;
+  }
+  if (options & WILD_ADD_SLASH) {
+    flags |= EW_ADDSLASH;
+  }
+  if (options & WILD_KEEP_ALL) {
+    flags |= EW_KEEPALL;
+  }
+  if (options & WILD_SILENT) {
+    flags |= EW_SILENT;
+  }
+  if (options & WILD_NOERROR) {
+    flags |= EW_NOERROR;
+  }
+  if (options & WILD_ALLLINKS) {
+    flags |= EW_ALLLINKS;
+  }
+
+  if (xp->xp_context == EXPAND_FILES
+      || xp->xp_context == EXPAND_DIRECTORIES
+      || xp->xp_context == EXPAND_FILES_IN_PATH) {
+    // Expand file or directory names.
+    bool free_pat = false;
+    int i;
+
+    // for ":set path=" and ":set tags=" halve backslashes for escaped space
+    if (xp->xp_backslash != XP_BS_NONE) {
+      free_pat = true;
+      pat = vim_strsave(pat);
+      for (i = 0; pat[i]; i++) {
+        if (pat[i] == '\\') {
+          if (xp->xp_backslash == XP_BS_THREE
+              && pat[i + 1] == '\\'
+              && pat[i + 2] == '\\'
+              && pat[i + 3] == ' ') {
+            STRMOVE(pat + i, pat + i + 3);
+          }
+          if (xp->xp_backslash == XP_BS_ONE
+              && pat[i + 1] == ' ') {
+            STRMOVE(pat + i, pat + i + 1);
+          }
+        }
+      }
+    }
+
+    if (xp->xp_context == EXPAND_FILES) {
+      flags |= EW_FILE;
+    } else if (xp->xp_context == EXPAND_FILES_IN_PATH) {
+      flags |= (EW_FILE | EW_PATH);
+    } else {
+      flags = (flags | EW_DIR) & ~EW_FILE;
+    }
+    if (options & WILD_ICASE) {
+      flags |= EW_ICASE;
+    }
+
+    // Expand wildcards, supporting %:h and the like.
+    ret = expand_wildcards_eval(&pat, num_file, file, flags);
+    if (free_pat) {
+      xfree(pat);
+    }
+#ifdef BACKSLASH_IN_FILENAME
+    if (p_csl[0] != NUL && (options & WILD_IGNORE_COMPLETESLASH) == 0) {
+      for (int i = 0; i < *num_file; i++) {
+        char_u *ptr = (*file)[i];
+        while (*ptr != NUL) {
+          if (p_csl[0] == 's' && *ptr == '\\') {
+            *ptr = '/';
+          } else if (p_csl[0] == 'b' && *ptr == '/') {
+            *ptr = '\\';
+          }
+          ptr += utfc_ptr2len(ptr);
+        }
+      }
+    }
+#endif
+    return ret;
+  }
+
+  *file = NULL;
+  *num_file = 0;
+  if (xp->xp_context == EXPAND_HELP) {
+    // With an empty argument we would get all the help tags, which is
+    // very slow.  Get matches for "help" instead.
+    if (find_help_tags(*pat == NUL ? "help" : (char *)pat,
+                       num_file, file, false) == OK) {
+      cleanup_help_tags(*num_file, *file);
+      return OK;
+    }
+    return FAIL;
+  }
+
+  if (xp->xp_context == EXPAND_SHELLCMD) {
+    *file = NULL;
+    expand_shellcmd(pat, num_file, file, flags);
+    return OK;
+  }
+  if (xp->xp_context == EXPAND_OLD_SETTING) {
+    ExpandOldSetting(num_file, file);
+    return OK;
+  }
+  if (xp->xp_context == EXPAND_BUFFERS) {
+    return ExpandBufnames((char *)pat, num_file, file, options);
+  }
+  if (xp->xp_context == EXPAND_DIFF_BUFFERS) {
+    return ExpandBufnames((char *)pat, num_file, file, options | BUF_DIFF_FILTER);
+  }
+  if (xp->xp_context == EXPAND_TAGS
+      || xp->xp_context == EXPAND_TAGS_LISTFILES) {
+    return expand_tags(xp->xp_context == EXPAND_TAGS, pat, num_file, file);
+  }
+  if (xp->xp_context == EXPAND_COLORS) {
+    char *directories[] = { "colors", NULL };
+    return ExpandRTDir(pat, DIP_START + DIP_OPT + DIP_LUA, num_file, file, directories);
+  }
+  if (xp->xp_context == EXPAND_COMPILER) {
+    char *directories[] = { "compiler", NULL };
+    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
+  }
+  if (xp->xp_context == EXPAND_OWNSYNTAX) {
+    char *directories[] = { "syntax", NULL };
+    return ExpandRTDir(pat, 0, num_file, file, directories);
+  }
+  if (xp->xp_context == EXPAND_FILETYPE) {
+    char *directories[] = { "syntax", "indent", "ftplugin", NULL };
+    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
+  }
+  if (xp->xp_context == EXPAND_USER_LIST) {
+    return ExpandUserList(xp, num_file, file);
+  }
+  if (xp->xp_context == EXPAND_USER_LUA) {
+    return ExpandUserLua(xp, num_file, file);
+  }
+  if (xp->xp_context == EXPAND_PACKADD) {
+    return ExpandPackAddDir(pat, num_file, file);
+  }
+
+  // When expanding a function name starting with s:, match the <SNR>nr_
+  // prefix.
+  char *tofree = NULL;
+  if (xp->xp_context == EXPAND_USER_FUNC && STRNCMP(pat, "^s:", 3) == 0) {
+    const size_t len = STRLEN(pat) + 20;
+
+    tofree = xmalloc(len);
+    snprintf(tofree, len, "^<SNR>\\d\\+_%s", pat + 3);
+    pat = (char_u *)tofree;
+  }
+
+  if (xp->xp_context == EXPAND_LUA) {
+    ILOG("PAT %s", pat);
+    return nlua_expand_pat(xp, pat, num_file, file);
+  }
+
+  regmatch.regprog = vim_regcomp((char *)pat, p_magic ? RE_MAGIC : 0);
+  if (regmatch.regprog == NULL) {
+    return FAIL;
+  }
+
+  // set ignore-case according to p_ic, p_scs and pat
+  regmatch.rm_ic = ignorecase(pat);
+
+  if (xp->xp_context == EXPAND_SETTINGS
+      || xp->xp_context == EXPAND_BOOL_SETTINGS) {
+    ret = ExpandSettings(xp, &regmatch, num_file, file);
+  } else if (xp->xp_context == EXPAND_MAPPINGS) {
+    ret = ExpandMappings(&regmatch, num_file, file);
+  } else if (xp->xp_context == EXPAND_USER_DEFINED) {
+    ret = ExpandUserDefined(xp, &regmatch, num_file, file);
+  } else {
+    static struct expgen {
+      int context;
+      ExpandFunc func;
+      int ic;
+      int escaped;
+    } tab[] = {
+      { EXPAND_COMMANDS, get_command_name, false, true },
+      { EXPAND_BEHAVE, get_behave_arg, true, true },
+      { EXPAND_MAPCLEAR, get_mapclear_arg, true, true },
+      { EXPAND_MESSAGES, get_messages_arg, true, true },
+      { EXPAND_HISTORY, get_history_arg, true, true },
+      { EXPAND_USER_COMMANDS, get_user_commands, false, true },
+      { EXPAND_USER_ADDR_TYPE, get_user_cmd_addr_type, false, true },
+      { EXPAND_USER_CMD_FLAGS, get_user_cmd_flags, false, true },
+      { EXPAND_USER_NARGS, get_user_cmd_nargs, false, true },
+      { EXPAND_USER_COMPLETE, get_user_cmd_complete, false, true },
+      { EXPAND_USER_VARS, get_user_var_name, false, true },
+      { EXPAND_FUNCTIONS, get_function_name, false, true },
+      { EXPAND_USER_FUNC, get_user_func_name, false, true },
+      { EXPAND_EXPRESSION, get_expr_name, false, true },
+      { EXPAND_MENUS, get_menu_name, false, true },
+      { EXPAND_MENUNAMES, get_menu_names, false, true },
+      { EXPAND_SYNTAX, get_syntax_name, true, true },
+      { EXPAND_SYNTIME, get_syntime_arg, true, true },
+      { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, true },
+      { EXPAND_EVENTS, expand_get_event_name, true, false },
+      { EXPAND_AUGROUP, expand_get_augroup_name, true, false },
+      { EXPAND_CSCOPE, get_cscope_name, true, true },
+      { EXPAND_SIGN, get_sign_name, true, true },
+      { EXPAND_PROFILE, get_profile_name, true, true },
+#ifdef HAVE_WORKING_LIBINTL
+      { EXPAND_LANGUAGE, get_lang_arg, true, false },
+      { EXPAND_LOCALES, get_locales, true, false },
+#endif
+      { EXPAND_ENV_VARS, get_env_name, true, true },
+      { EXPAND_USER, get_users, true, false },
+      { EXPAND_ARGLIST, get_arglist_name, true, false },
+      { EXPAND_CHECKHEALTH, get_healthcheck_names, true, false },
+    };
+
+    // Find a context in the table and call the ExpandGeneric() with the
+    // right function to do the expansion.
+    ret = FAIL;
+    for (int i = 0; i < (int)ARRAY_SIZE(tab); i++) {
+      if (xp->xp_context == tab[i].context) {
+        if (tab[i].ic) {
+          regmatch.rm_ic = true;
+        }
+        ExpandGeneric(xp, &regmatch, num_file, file, tab[i].func, tab[i].escaped);
+        ret = OK;
+        break;
+      }
+    }
+  }
+
+  vim_regfree(regmatch.regprog);
+  xfree(tofree);
+
+  return ret;
+}
+
+/// Expand a list of names.
+///
+/// Generic function for command line completion.  It calls a function to
+/// obtain strings, one by one.  The strings are matched against a regexp
+/// program.  Matching strings are copied into an array, which is returned.
+///
+/// @param func  returns a string from the list
+static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file,
+                          CompleteListItemGetter func, int escaped)
+{
+  int i;
+  size_t count = 0;
+  char_u *str;
+
+  // count the number of matching names
+  for (i = 0;; i++) {
+    str = (char_u *)(*func)(xp, i);
+    if (str == NULL) {  // end of list
+      break;
+    }
+    if (*str == NUL) {  // skip empty strings
+      continue;
+    }
+    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
+      count++;
+    }
+  }
+  if (count == 0) {
+    return;
+  }
+  assert(count < INT_MAX);
+  *num_file = (int)count;
+  *file = xmalloc(count * sizeof(char_u *));
+
+  // copy the matching names into allocated memory
+  count = 0;
+  for (i = 0;; i++) {
+    str = (char_u *)(*func)(xp, i);
+    if (str == NULL) {  // End of list.
+      break;
+    }
+    if (*str == NUL) {  // Skip empty strings.
+      continue;
+    }
+    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
+      if (escaped) {
+        str = vim_strsave_escaped(str, (char_u *)" \t\\.");
+      } else {
+        str = vim_strsave(str);
+      }
+      (*file)[count++] = (char *)str;
+      if (func == get_menu_names) {
+        // Test for separator added by get_menu_names().
+        str += STRLEN(str) - 1;
+        if (*str == '\001') {
+          *str = '.';
+        }
+      }
+    }
+  }
+
+  // Sort the results.  Keep menu's in the specified order.
+  if (xp->xp_context != EXPAND_MENUNAMES && xp->xp_context != EXPAND_MENUS) {
+    if (xp->xp_context == EXPAND_EXPRESSION
+        || xp->xp_context == EXPAND_FUNCTIONS
+        || xp->xp_context == EXPAND_USER_FUNC) {
+      // <SNR> functions should be sorted to the end.
+      qsort((void *)(*file), (size_t)(*num_file), sizeof(char_u *),
+            sort_func_compare);
+    } else {
+      sort_strings(*file, *num_file);
+    }
+  }
+
+  // Reset the variables used for special highlight names expansion, so that
+  // they don't show up when getting normal highlight names by ID.
+  reset_expand_highlight();
+}
+
+/// Complete a shell command.
+///
+/// @param      filepat  is a pattern to match with command names.
+/// @param[out] num_file is pointer to number of matches.
+/// @param[out] file     is pointer to array of pointers to matches.
+///                      *file will either be set to NULL or point to
+///                      allocated memory.
+/// @param      flagsarg is a combination of EW_* flags.
+static void expand_shellcmd(char_u *filepat, int *num_file, char ***file, int flagsarg)
+  FUNC_ATTR_NONNULL_ALL
+{
+  char_u *pat;
+  int i;
+  char_u *path = NULL;
+  garray_T ga;
+  char *buf = xmalloc(MAXPATHL);
+  size_t l;
+  char_u *s, *e;
+  int flags = flagsarg;
+  int ret;
+  bool did_curdir = false;
+
+  // for ":set path=" and ":set tags=" halve backslashes for escaped space
+  pat = vim_strsave(filepat);
+  for (i = 0; pat[i]; i++) {
+    if (pat[i] == '\\' && pat[i + 1] == ' ') {
+      STRMOVE(pat + i, pat + i + 1);
+    }
+  }
+
+  flags |= EW_FILE | EW_EXEC | EW_SHELLCMD;
+
+  bool mustfree = false;  // Track memory allocation for *path.
+  if (pat[0] == '.' && (vim_ispathsep(pat[1])
+                        || (pat[1] == '.' && vim_ispathsep(pat[2])))) {
+    path = (char_u *)".";
+  } else {
+    // For an absolute name we don't use $PATH.
+    if (!path_is_absolute(pat)) {
+      path = (char_u *)vim_getenv("PATH");
+    }
+    if (path == NULL) {
+      path = (char_u *)"";
+    } else {
+      mustfree = true;
+    }
+  }
+
+  // Go over all directories in $PATH.  Expand matches in that directory and
+  // collect them in "ga". When "." is not in $PATH also expaned for the
+  // current directory, to find "subdir/cmd".
+  ga_init(&ga, (int)sizeof(char *), 10);
+  hashtab_T found_ht;
+  hash_init(&found_ht);
+  for (s = path;; s = e) {
+    e = (char_u *)vim_strchr((char *)s, ENV_SEPCHAR);
+    if (e == NULL) {
+      e = s + STRLEN(s);
+    }
+
+    if (*s == NUL) {
+      if (did_curdir) {
+        break;
+      }
+      // Find directories in the current directory, path is empty.
+      did_curdir = true;
+      flags |= EW_DIR;
+    } else if (STRNCMP(s, ".", e - s) == 0) {
+      did_curdir = true;
+      flags |= EW_DIR;
+    } else {
+      // Do not match directories inside a $PATH item.
+      flags &= ~EW_DIR;
+    }
+
+    l = (size_t)(e - s);
+    if (l > MAXPATHL - 5) {
+      break;
+    }
+    STRLCPY(buf, s, l + 1);
+    add_pathsep(buf);
+    l = STRLEN(buf);
+    STRLCPY(buf + l, pat, MAXPATHL - l);
+
+    // Expand matches in one directory of $PATH.
+    ret = expand_wildcards(1, &buf, num_file, file, flags);
+    if (ret == OK) {
+      ga_grow(&ga, *num_file);
+      {
+        for (i = 0; i < *num_file; i++) {
+          char_u *name = (char_u *)(*file)[i];
+
+          if (STRLEN(name) > l) {
+            // Check if this name was already found.
+            hash_T hash = hash_hash(name + l);
+            hashitem_T *hi =
+              hash_lookup(&found_ht, (const char *)(name + l),
+                          STRLEN(name + l), hash);
+            if (HASHITEM_EMPTY(hi)) {
+              // Remove the path that was prepended.
+              STRMOVE(name, name + l);
+              ((char_u **)ga.ga_data)[ga.ga_len++] = name;
+              hash_add_item(&found_ht, hi, name, hash);
+              name = NULL;
+            }
+          }
+          xfree(name);
+        }
+        xfree(*file);
+      }
+    }
+    if (*e != NUL) {
+      e++;
+    }
+  }
+  *file = ga.ga_data;
+  *num_file = ga.ga_len;
+
+  xfree(buf);
+  xfree(pat);
+  if (mustfree) {
+    xfree(path);
+  }
+  hash_clear(&found_ht);
+}
+
+/// Call "user_expand_func()" to invoke a user defined Vim script function and
+/// return the result (either a string, a List or NULL).
+static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T *xp, int *num_file,
+                                   char ***file)
+  FUNC_ATTR_NONNULL_ALL
+{
+  CmdlineInfo *const ccline = get_cmdline_info();
+  char_u keep = 0;
+  typval_T args[4];
+  char_u *pat = NULL;
+  const sctx_T save_current_sctx = current_sctx;
+
+  if (xp->xp_arg == NULL || xp->xp_arg[0] == '\0' || xp->xp_line == NULL) {
+    return NULL;
+  }
+  *num_file = 0;
+  *file = NULL;
+
+  if (ccline->cmdbuff != NULL) {
+    keep = ccline->cmdbuff[ccline->cmdlen];
+    ccline->cmdbuff[ccline->cmdlen] = 0;
+  }
+
+  pat = vim_strnsave((char_u *)xp->xp_pattern, xp->xp_pattern_len);
+  args[0].v_type = VAR_STRING;
+  args[1].v_type = VAR_STRING;
+  args[2].v_type = VAR_NUMBER;
+  args[3].v_type = VAR_UNKNOWN;
+  args[0].vval.v_string = (char *)pat;
+  args[1].vval.v_string = xp->xp_line;
+  args[2].vval.v_number = xp->xp_col;
+
+  current_sctx = xp->xp_script_ctx;
+
+  void *const ret = user_expand_func((char_u *)xp->xp_arg, 3, args);
+
+  current_sctx = save_current_sctx;
+  if (ccline->cmdbuff != NULL) {
+    ccline->cmdbuff[ccline->cmdlen] = keep;
+  }
+
+  xfree(pat);
+  return ret;
+}
+
+/// Expand names with a function defined by the user.
+static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file)
+{
+  char_u *e;
+  garray_T ga;
+
+  char_u *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
+                                               file);
+
+  if (retstr == NULL) {
+    return FAIL;
+  }
+
+  ga_init(&ga, (int)sizeof(char *), 3);
+  for (char_u *s = retstr; *s != NUL; s = e) {
+    e = (char_u *)vim_strchr((char *)s, '\n');
+    if (e == NULL) {
+      e = s + STRLEN(s);
+    }
+    const char_u keep = *e;
+    *e = NUL;
+
+    const bool skip = xp->xp_pattern[0]
+                      && vim_regexec(regmatch, (char *)s, (colnr_T)0) == 0;
+    *e = keep;
+    if (!skip) {
+      GA_APPEND(char_u *, &ga, vim_strnsave(s, (size_t)(e - s)));
+    }
+
+    if (*e != NUL) {
+      e++;
+    }
+  }
+  xfree(retstr);
+  *file = ga.ga_data;
+  *num_file = ga.ga_len;
+  return OK;
+}
+
+/// Expand names with a list returned by a function defined by the user.
+static int ExpandUserList(expand_T *xp, int *num_file, char ***file)
+{
+  list_T *const retlist = call_user_expand_func((user_expand_func_T)call_func_retlist, xp, num_file,
+                                                file);
+  if (retlist == NULL) {
+    return FAIL;
+  }
+
+  garray_T ga;
+  ga_init(&ga, (int)sizeof(char *), 3);
+  // Loop over the items in the list.
+  TV_LIST_ITER_CONST(retlist, li, {
+    if (TV_LIST_ITEM_TV(li)->v_type != VAR_STRING
+        || TV_LIST_ITEM_TV(li)->vval.v_string == NULL) {
+      continue;  // Skip non-string items and empty strings.
+    }
+
+    GA_APPEND(char *, &ga, xstrdup((const char *)TV_LIST_ITEM_TV(li)->vval.v_string));
+  });
+  tv_list_unref(retlist);
+
+  *file = ga.ga_data;
+  *num_file = ga.ga_len;
+  return OK;
+}
+
+static int ExpandUserLua(expand_T *xp, int *num_file, char ***file)
+{
+  typval_T rettv;
+  nlua_call_user_expand_func(xp, &rettv);
+  if (rettv.v_type != VAR_LIST) {
+    tv_clear(&rettv);
+    return FAIL;
+  }
+
+  list_T *const retlist = rettv.vval.v_list;
+
+  garray_T ga;
+  ga_init(&ga, (int)sizeof(char *), 3);
+  // Loop over the items in the list.
+  TV_LIST_ITER_CONST(retlist, li, {
+    if (TV_LIST_ITEM_TV(li)->v_type != VAR_STRING
+        || TV_LIST_ITEM_TV(li)->vval.v_string == NULL) {
+      continue;  // Skip non-string items and empty strings.
+    }
+
+    GA_APPEND(char *, &ga, xstrdup((const char *)TV_LIST_ITEM_TV(li)->vval.v_string));
+  });
+  tv_list_unref(retlist);
+
+  *file = ga.ga_data;
+  *num_file = ga.ga_len;
+  return OK;
+}
+
+/// Expand `file` for all comma-separated directories in `path`.
+/// Adds matches to `ga`.
+void globpath(char *path, char_u *file, garray_T *ga, int expand_options)
+{
+  expand_T xpc;
+  ExpandInit(&xpc);
+  xpc.xp_context = EXPAND_FILES;
+
+  char_u *buf = xmalloc(MAXPATHL);
+
+  // Loop over all entries in {path}.
+  while (*path != NUL) {
+    // Copy one item of the path to buf[] and concatenate the file name.
+    copy_option_part(&path, (char *)buf, MAXPATHL, ",");
+    if (STRLEN(buf) + STRLEN(file) + 2 < MAXPATHL) {
+      add_pathsep((char *)buf);
+      STRCAT(buf, file);  // NOLINT
+
+      char **p;
+      int num_p = 0;
+      (void)ExpandFromContext(&xpc, buf, &num_p, &p,
+                              WILD_SILENT | expand_options);
+      if (num_p > 0) {
+        ExpandEscape(&xpc, buf, num_p, p, WILD_SILENT | expand_options);
+
+        // Concatenate new results to previous ones.
+        ga_grow(ga, num_p);
+        // take over the pointers and put them in "ga"
+        for (int i = 0; i < num_p; i++) {
+          ((char_u **)ga->ga_data)[ga->ga_len] = (char_u *)p[i];
+          ga->ga_len++;
+        }
+        xfree(p);
+      }
+    }
+  }
+
+  xfree(buf);
+}
+
+/// "getcompletion()" function
+void f_getcompletion(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+{
+  char_u *pat;
+  expand_T xpc;
+  bool filtered = false;
+  int options = WILD_SILENT | WILD_USE_NL | WILD_ADD_SLASH
+                | WILD_NO_BEEP | WILD_HOME_REPLACE;
+
+  if (argvars[1].v_type != VAR_STRING) {
+    semsg(_(e_invarg2), "type must be a string");
+    return;
+  }
+  const char *const type = tv_get_string(&argvars[1]);
+
+  if (argvars[2].v_type != VAR_UNKNOWN) {
+    filtered = (bool)tv_get_number_chk(&argvars[2], NULL);
+  }
+
+  if (p_wic) {
+    options |= WILD_ICASE;
+  }
+
+  // For filtered results, 'wildignore' is used
+  if (!filtered) {
+    options |= WILD_KEEP_ALL;
+  }
+
+  if (argvars[0].v_type != VAR_STRING) {
+    emsg(_(e_invarg));
+    return;
+  }
+  const char *pattern = tv_get_string(&argvars[0]);
+
+  if (strcmp(type, "cmdline") == 0) {
+    set_one_cmd_context(&xpc, pattern);
+    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
+    xpc.xp_col = (int)STRLEN(pattern);
+    goto theend;
+  }
+
+  ExpandInit(&xpc);
+  xpc.xp_pattern = (char *)pattern;
+  xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
+  xpc.xp_context = cmdcomplete_str_to_type(type);
+  if (xpc.xp_context == EXPAND_NOTHING) {
+    semsg(_(e_invarg2), type);
+    return;
+  }
+
+  if (xpc.xp_context == EXPAND_MENUS) {
+    set_context_in_menu_cmd(&xpc, "menu", xpc.xp_pattern, false);
+    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
+  }
+
+  if (xpc.xp_context == EXPAND_CSCOPE) {
+    set_context_in_cscope_cmd(&xpc, (const char *)xpc.xp_pattern, CMD_cscope);
+    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
+  }
+
+  if (xpc.xp_context == EXPAND_SIGN) {
+    set_context_in_sign_cmd(&xpc, (char_u *)xpc.xp_pattern);
+    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
+  }
+
+theend:
+  pat = addstar((char_u *)xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
+  ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
+  tv_list_alloc_ret(rettv, xpc.xp_numfiles);
+
+  for (int i = 0; i < xpc.xp_numfiles; i++) {
+    tv_list_append_string(rettv->vval.v_list, (const char *)xpc.xp_files[i],
+                          -1);
+  }
+  xfree(pat);
+  ExpandCleanup(&xpc);
+}
diff --git a/src/nvim/cmdexpand.h b/src/nvim/cmdexpand.h
new file mode 100644
index 0000000000..f534a2e0d3
--- /dev/null
+++ b/src/nvim/cmdexpand.h
@@ -0,0 +1,43 @@
+#ifndef NVIM_CMDEXPAND_H
+#define NVIM_CMDEXPAND_H
+
+#include "nvim/eval/typval.h"
+#include "nvim/garray.h"
+#include "nvim/types.h"
+
+// Values for nextwild() and ExpandOne().  See ExpandOne() for meaning.
+
+enum {
+  WILD_FREE        = 1,
+  WILD_EXPAND_FREE = 2,
+  WILD_EXPAND_KEEP = 3,
+  WILD_NEXT        = 4,
+  WILD_PREV        = 5,
+  WILD_ALL         = 6,
+  WILD_LONGEST     = 7,
+  WILD_ALL_KEEP    = 8,
+  WILD_CANCEL      = 9,
+  WILD_APPLY       = 10,
+};
+
+enum {
+  WILD_LIST_NOTFOUND        = 0x01,
+  WILD_HOME_REPLACE         = 0x02,
+  WILD_USE_NL               = 0x04,
+  WILD_NO_BEEP              = 0x08,
+  WILD_ADD_SLASH            = 0x10,
+  WILD_KEEP_ALL             = 0x20,
+  WILD_SILENT               = 0x40,
+  WILD_ESCAPE               = 0x80,
+  WILD_ICASE                = 0x100,
+  WILD_ALLLINKS             = 0x200,
+  WILD_IGNORE_COMPLETESLASH = 0x400,
+  WILD_NOERROR              = 0x800,  ///< sets EW_NOERROR
+  WILD_BUFLASTUSED          = 0x1000,
+  BUF_DIFF_FILTER           = 0x2000,
+};
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "cmdexpand.h.generated.h"
+#endif
+#endif  // NVIM_CMDEXPAND_H
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 5725a6655d..13f97ba1e8 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -6,6 +6,7 @@
 #include "nvim/ascii.h"
 #include "nvim/charset.h"
 #include "nvim/cmdhist.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_getln.h"
 #include "nvim/regexp.h"
 #include "nvim/strings.h"
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 41d7d22934..2abff6c894 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -61,6 +61,7 @@
 
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/diff.h"
 #include "nvim/drawscreen.h"
 #include "nvim/ex_getln.h"
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index c39fe44162..cb46e26f82 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -28,6 +28,7 @@
 #include "nvim/eval/typval.h"
 #include "nvim/eval/userfunc.h"
 #include "nvim/eval/vars.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_eval.h"
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 940f245d53..8b491fcc7a 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -14,6 +14,7 @@
 #include "nvim/change.h"
 #include "nvim/channel.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cmdhist.h"
 #include "nvim/context.h"
 #include "nvim/cursor.h"
@@ -28,6 +29,7 @@
 #include "nvim/eval/typval.h"
 #include "nvim/eval/userfunc.h"
 #include "nvim/eval/vars.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_eval.h"
 #include "nvim/ex_getln.h"
@@ -2751,84 +2753,6 @@ static void f_getcmdwintype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   rettv->vval.v_string[0] = (char)cmdwin_type;
 }
 
-/// "getcompletion()" function
-static void f_getcompletion(typval_T *argvars, typval_T *rettv, FunPtr fptr)
-{
-  char_u *pat;
-  expand_T xpc;
-  bool filtered = false;
-  int options = WILD_SILENT | WILD_USE_NL | WILD_ADD_SLASH
-                | WILD_NO_BEEP | WILD_HOME_REPLACE;
-
-  if (argvars[1].v_type != VAR_STRING) {
-    semsg(_(e_invarg2), "type must be a string");
-    return;
-  }
-  const char *const type = tv_get_string(&argvars[1]);
-
-  if (argvars[2].v_type != VAR_UNKNOWN) {
-    filtered = (bool)tv_get_number_chk(&argvars[2], NULL);
-  }
-
-  if (p_wic) {
-    options |= WILD_ICASE;
-  }
-
-  // For filtered results, 'wildignore' is used
-  if (!filtered) {
-    options |= WILD_KEEP_ALL;
-  }
-
-  if (argvars[0].v_type != VAR_STRING) {
-    emsg(_(e_invarg));
-    return;
-  }
-  const char *pattern = tv_get_string(&argvars[0]);
-
-  if (strcmp(type, "cmdline") == 0) {
-    set_one_cmd_context(&xpc, pattern);
-    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
-    xpc.xp_col = (int)STRLEN(pattern);
-    goto theend;
-  }
-
-  ExpandInit(&xpc);
-  xpc.xp_pattern = (char *)pattern;
-  xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
-  xpc.xp_context = cmdcomplete_str_to_type(type);
-  if (xpc.xp_context == EXPAND_NOTHING) {
-    semsg(_(e_invarg2), type);
-    return;
-  }
-
-  if (xpc.xp_context == EXPAND_MENUS) {
-    set_context_in_menu_cmd(&xpc, "menu", xpc.xp_pattern, false);
-    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
-  }
-
-  if (xpc.xp_context == EXPAND_CSCOPE) {
-    set_context_in_cscope_cmd(&xpc, (const char *)xpc.xp_pattern, CMD_cscope);
-    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
-  }
-
-  if (xpc.xp_context == EXPAND_SIGN) {
-    set_context_in_sign_cmd(&xpc, (char_u *)xpc.xp_pattern);
-    xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
-  }
-
-theend:
-  pat = addstar((char_u *)xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
-  ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
-  tv_list_alloc_ret(rettv, xpc.xp_numfiles);
-
-  for (int i = 0; i < xpc.xp_numfiles; i++) {
-    tv_list_append_string(rettv->vval.v_list, (const char *)xpc.xp_files[i],
-                          -1);
-  }
-  xfree(pat);
-  ExpandCleanup(&xpc);
-}
-
 /// `getcwd([{win}[, {tab}]])` function
 ///
 /// Every scope not specified implies the currently selected scope object.
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 6cd6e32e72..bc6a05568b 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -14,6 +14,7 @@
 #include "nvim/buffer.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cmdhist.h"
 #include "nvim/cursor.h"
 #include "nvim/debugger.h"
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 4629cb98ea..c14eca6604 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -12,14 +12,13 @@
 #include <string.h>
 
 #include "nvim/api/extmark.h"
-#include "nvim/api/private/helpers.h"
 #include "nvim/api/vim.h"
 #include "nvim/arabic.h"
-#include "nvim/arglist.h"
 #include "nvim/ascii.h"
 #include "nvim/assert.h"
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cmdhist.h"
 #include "nvim/cursor.h"
 #include "nvim/cursor_shape.h"
@@ -27,11 +26,8 @@
 #include "nvim/drawscreen.h"
 #include "nvim/edit.h"
 #include "nvim/eval.h"
-#include "nvim/eval/funcs.h"
-#include "nvim/eval/userfunc.h"
 #include "nvim/event/loop.h"
 #include "nvim/ex_cmds.h"
-#include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_eval.h"
 #include "nvim/ex_getln.h"
@@ -41,23 +37,19 @@
 #include "nvim/getchar.h"
 #include "nvim/globals.h"
 #include "nvim/grid.h"
-#include "nvim/help.h"
 #include "nvim/highlight.h"
 #include "nvim/highlight_defs.h"
 #include "nvim/highlight_group.h"
-#include "nvim/if_cscope.h"
 #include "nvim/indent.h"
 #include "nvim/keycodes.h"
 #include "nvim/lib/kvec.h"
 #include "nvim/log.h"
-#include "nvim/lua/executor.h"
 #include "nvim/main.h"
 #include "nvim/mapping.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
-#include "nvim/menu.h"
 #include "nvim/message.h"
 #include "nvim/mouse.h"
 #include "nvim/move.h"
@@ -65,87 +57,22 @@
 #include "nvim/option.h"
 #include "nvim/optionstr.h"
 #include "nvim/os/input.h"
-#include "nvim/os/os.h"
 #include "nvim/os/time.h"
-#include "nvim/os_unix.h"
 #include "nvim/path.h"
 #include "nvim/popupmenu.h"
 #include "nvim/profile.h"
 #include "nvim/regexp.h"
 #include "nvim/search.h"
-#include "nvim/sign.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
-#include "nvim/syntax.h"
-#include "nvim/tag.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
+#include "nvim/usercmd.h"
 #include "nvim/vim.h"
 #include "nvim/viml/parser/expressions.h"
 #include "nvim/viml/parser/parser.h"
 #include "nvim/window.h"
 
-/// Command-line colors: one chunk
-///
-/// Defines a region which has the same highlighting.
-typedef struct {
-  int start;  ///< Colored chunk start.
-  int end;  ///< Colored chunk end (exclusive, > start).
-  int attr;  ///< Highlight attr.
-} CmdlineColorChunk;
-
-/// Command-line colors
-///
-/// Holds data about all colors.
-typedef kvec_t(CmdlineColorChunk) CmdlineColors;
-
-/// Command-line coloring
-///
-/// Holds both what are the colors and what have been colored. Latter is used to
-/// suppress unnecessary calls to coloring callbacks.
-typedef struct {
-  unsigned prompt_id;  ///< ID of the prompt which was colored last.
-  char *cmdbuff;  ///< What exactly was colored last time or NULL.
-  CmdlineColors colors;  ///< Last colors.
-} ColoredCmdline;
-
-/// Keeps track how much state must be sent to external ui.
-typedef enum {
-  kCmdRedrawNone,
-  kCmdRedrawPos,
-  kCmdRedrawAll,
-} CmdRedraw;
-
-// Variables shared between getcmdline(), redrawcmdline() and others.
-// These need to be saved when using CTRL-R |, that's why they are in a
-// structure.
-struct cmdline_info {
-  char_u *cmdbuff;         // pointer to command line buffer
-  int cmdbufflen;               // length of cmdbuff
-  int cmdlen;                   // number of chars in command line
-  int cmdpos;                   // current cursor position
-  int cmdspos;                  // cursor column on screen
-  int cmdfirstc;                // ':', '/', '?', '=', '>' or NUL
-  int cmdindent;                // number of spaces before cmdline
-  char_u *cmdprompt;       // message in front of cmdline
-  int cmdattr;                  // attributes for prompt
-  int overstrike;               // Typing mode on the command line.  Shared by
-                                // getcmdline() and put_on_cmdline().
-  expand_T *xpc;             // struct being used for expansion, xp_pattern
-                             // may point into cmdbuff
-  int xp_context;               // type of expansion
-  char_u *xp_arg;          // user-defined expansion arg
-  int input_fn;                 // when TRUE Invoked for input() function
-  unsigned prompt_id;  ///< Prompt number, used to disable coloring on errors.
-  Callback highlight_callback;  ///< Callback used for coloring user input.
-  ColoredCmdline last_colors;   ///< Last cmdline colors
-  int level;                    // current cmdline level
-  struct cmdline_info *prev_ccline;  ///< pointer to saved cmdline state
-  char special_char;            ///< last putcmdline char (used for redraws)
-  bool special_shift;           ///< shift of last putcmdline char
-  CmdRedraw redraw_state;       ///< needed redraw for external cmdline
-};
-
 /// Last value of prompt_id, incremented when doing new prompt
 static unsigned last_prompt_id = 0;
 
@@ -227,38 +154,28 @@ typedef struct cmdpreview_info {
   garray_T save_view;
 } CpInfo;
 
-typedef struct cmdline_info CmdlineInfo;
-
 /// The current cmdline_info.  It is initialized in getcmdline() and after that
 /// used by other functions.  When invoking getcmdline() recursively it needs
 /// to be saved with save_cmdline() and restored with restore_cmdline().
-static struct cmdline_info ccline;
-
-static int cmd_showtail;        // Only show path tail in lists ?
+static CmdlineInfo ccline;
 
 static int new_cmdpos;          // position set by set_cmdline_pos()
 
 /// currently displayed block of context
 static Array cmdline_block = ARRAY_DICT_INIT;
 
-/*
- * Type used by call_user_expand_func
- */
-typedef void *(*user_expand_func_T)(const char_u *, int, typval_T *);
-
 /// Flag for command_line_handle_key to ignore <C-c>
 ///
 /// Used if it was received while processing highlight function in order for
 /// user interrupting highlight function to not interrupt command-line.
 static bool getln_interrupted_highlight = false;
 
-// "compl_match_array" points the currently displayed list of entries in the
-// popup menu.  It is NULL when there is no popup menu.
-static pumitem_T *compl_match_array = NULL;
-static int compl_match_arraysize;
-// First column in cmdline of the matched item for completion.
-static int compl_startcol;
-static int compl_selected;
+// TODO(zeertzjq): make these four variables static in cmdexpand.c
+
+extern pumitem_T *compl_match_array;
+extern int compl_match_arraysize;
+extern int compl_startcol;
+extern int compl_selected;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ex_getln.c.generated.h"
@@ -304,32 +221,6 @@ static void init_incsearch_state(incsearch_state_T *s)
   save_viewstate(curwin, &s->old_viewstate);
 }
 
-/// Completion for |:checkhealth| command.
-///
-/// Given to ExpandGeneric() to obtain all available heathcheck names.
-/// @param[in] idx  Index of the healthcheck item.
-/// @param[in] xp  Not used.
-static char *get_healthcheck_names(expand_T *xp, int idx)
-{
-  static Object names = OBJECT_INIT;
-  static unsigned last_gen = 0;
-
-  if (last_gen != last_prompt_id || last_gen == 0) {
-    Array a = ARRAY_DICT_INIT;
-    Error err = ERROR_INIT;
-    Object res = nlua_exec(STATIC_CSTR_AS_STRING("return vim.health._complete()"), a, &err);
-    api_clear_error(&err);
-    api_free_object(names);
-    names = res;
-    last_gen = last_prompt_id;
-  }
-
-  if (names.type == kObjectTypeArray && idx < (int)names.data.array.size) {
-    return names.data.array.items[idx].data.string.data;
-  }
-  return NULL;
-}
-
 // Return true when 'incsearch' highlighting is to be done.
 // Sets search_first_line and search_last_line to the address range.
 static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_state_T *s,
@@ -2895,7 +2786,7 @@ static int cmd_startcol(void)
 }
 
 /// Compute the column position for a byte position on the command line.
-static int cmd_screencol(int bytepos)
+int cmd_screencol(int bytepos)
 {
   int m;  // maximum column
 
@@ -2982,10 +2873,8 @@ static void alloc_cmdbuff(int len)
   ccline.cmdbufflen = len;
 }
 
-/*
- * Re-allocate the command line to length len + something extra.
- */
-static void realloc_cmdbuff(int len)
+/// Re-allocate the command line to length len + something extra.
+void realloc_cmdbuff(int len)
 {
   if (len < ccline.cmdbufflen) {
     return;  // no need to resize
@@ -3742,7 +3631,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
 
 /// Save ccline, because obtaining the "=" register may execute "normal :cmd"
 /// and overwrite it.
-static void save_cmdline(struct cmdline_info *ccp)
+static void save_cmdline(CmdlineInfo *ccp)
 {
   *ccp = ccline;
   CLEAR_FIELD(ccline);
@@ -3751,7 +3640,7 @@ static void save_cmdline(struct cmdline_info *ccp)
 }
 
 /// Restore ccline after it has been saved with save_cmdline().
-static void restore_cmdline(struct cmdline_info *ccp)
+static void restore_cmdline(CmdlineInfo *ccp)
   FUNC_ATTR_NONNULL_ALL
 {
   ccline = *ccp;
@@ -3977,7 +3866,7 @@ void compute_cmdrow(void)
   lines_left = cmdline_row;
 }
 
-static void cursorcmd(void)
+void cursorcmd(void)
 {
   if (cmd_silent) {
     return;
@@ -4064,462 +3953,6 @@ static int ccheck_abbr(int c)
   return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, spos);
 }
 
-static int sort_func_compare(const void *s1, const void *s2)
-{
-  char_u *p1 = *(char_u **)s1;
-  char_u *p2 = *(char_u **)s2;
-
-  if (*p1 != '<' && *p2 == '<') {
-    return -1;
-  }
-  if (*p1 == '<' && *p2 != '<') {
-    return 1;
-  }
-  return STRCMP(p1, p2);
-}
-
-/// Return FAIL if this is not an appropriate context in which to do
-/// completion of anything, return OK if it is (even if there are no matches).
-/// For the caller, this means that the character is just passed through like a
-/// normal character (instead of being expanded).  This allows :s/^I^D etc.
-///
-/// @param options  extra options for ExpandOne()
-/// @param escape  if TRUE, escape the returned matches
-static int nextwild(expand_T *xp, int type, int options, int escape)
-{
-  int i, j;
-  char_u *p1;
-  char_u *p2;
-  int difflen;
-
-  if (xp->xp_numfiles == -1) {
-    set_expand_context(xp);
-    cmd_showtail = expand_showtail(xp);
-  }
-
-  if (xp->xp_context == EXPAND_UNSUCCESSFUL) {
-    beep_flush();
-    return OK;      // Something illegal on command line
-  }
-  if (xp->xp_context == EXPAND_NOTHING) {
-    // Caller can use the character as a normal char instead
-    return FAIL;
-  }
-
-  if (!(ui_has(kUICmdline) || ui_has(kUIWildmenu))) {
-    msg_puts("...");  // show that we are busy
-    ui_flush();
-  }
-
-  i = (int)((char_u *)xp->xp_pattern - ccline.cmdbuff);
-  assert(ccline.cmdpos >= i);
-  xp->xp_pattern_len = (size_t)ccline.cmdpos - (size_t)i;
-
-  if (type == WILD_NEXT || type == WILD_PREV) {
-    // Get next/previous match for a previous expanded pattern.
-    p2 = ExpandOne(xp, NULL, NULL, 0, type);
-  } else {
-    // Translate string into pattern and expand it.
-    p1 = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
-    const int use_options = (
-                             options
-                             | WILD_HOME_REPLACE
-                             | WILD_ADD_SLASH
-                             | WILD_SILENT
-                             | (escape ? WILD_ESCAPE : 0)
-                             | (p_wic ? WILD_ICASE : 0));
-    p2 = ExpandOne(xp, p1, vim_strnsave(&ccline.cmdbuff[i], xp->xp_pattern_len),
-                   use_options, type);
-    xfree(p1);
-
-    // xp->xp_pattern might have been modified by ExpandOne (for example,
-    // in lua completion), so recompute the pattern index and length
-    i = (int)((char_u *)xp->xp_pattern - ccline.cmdbuff);
-    xp->xp_pattern_len = (size_t)ccline.cmdpos - (size_t)i;
-
-    // Longest match: make sure it is not shorter, happens with :help.
-    if (p2 != NULL && type == WILD_LONGEST) {
-      for (j = 0; (size_t)j < xp->xp_pattern_len; j++) {
-        if (ccline.cmdbuff[i + j] == '*'
-            || ccline.cmdbuff[i + j] == '?') {
-          break;
-        }
-      }
-      if ((int)STRLEN(p2) < j) {
-        XFREE_CLEAR(p2);
-      }
-    }
-  }
-
-  if (p2 != NULL && !got_int) {
-    difflen = (int)STRLEN(p2) - (int)(xp->xp_pattern_len);
-    if (ccline.cmdlen + difflen + 4 > ccline.cmdbufflen) {
-      realloc_cmdbuff(ccline.cmdlen + difflen + 4);
-      xp->xp_pattern = (char *)ccline.cmdbuff + i;
-    }
-    assert(ccline.cmdpos <= ccline.cmdlen);
-    memmove(&ccline.cmdbuff[ccline.cmdpos + difflen],
-            &ccline.cmdbuff[ccline.cmdpos],
-            (size_t)ccline.cmdlen - (size_t)ccline.cmdpos + 1);
-    memmove(&ccline.cmdbuff[i], p2, STRLEN(p2));
-    ccline.cmdlen += difflen;
-    ccline.cmdpos += difflen;
-  }
-  xfree(p2);
-
-  redrawcmd();
-  cursorcmd();
-
-  /* When expanding a ":map" command and no matches are found, assume that
-   * the key is supposed to be inserted literally */
-  if (xp->xp_context == EXPAND_MAPPINGS && p2 == NULL) {
-    return FAIL;
-  }
-
-  if (xp->xp_numfiles <= 0 && p2 == NULL) {
-    beep_flush();
-  } else if (xp->xp_numfiles == 1) {
-    // free expanded pattern
-    (void)ExpandOne(xp, NULL, NULL, 0, WILD_FREE);
-  }
-
-  return OK;
-}
-
-/// Do wildcard expansion on the string 'str'.
-/// Chars that should not be expanded must be preceded with a backslash.
-/// Return a pointer to allocated memory containing the new string.
-/// Return NULL for failure.
-///
-/// "orig" is the originally expanded string, copied to allocated memory.  It
-/// should either be kept in orig_save or freed.  When "mode" is WILD_NEXT or
-/// WILD_PREV "orig" should be NULL.
-///
-/// Results are cached in xp->xp_files and xp->xp_numfiles, except when "mode"
-/// is WILD_EXPAND_FREE or WILD_ALL.
-///
-/// mode = WILD_FREE:        just free previously expanded matches
-/// mode = WILD_EXPAND_FREE: normal expansion, do not keep matches
-/// mode = WILD_EXPAND_KEEP: normal expansion, keep matches
-/// mode = WILD_NEXT:        use next match in multiple match, wrap to first
-/// mode = WILD_PREV:        use previous match in multiple match, wrap to first
-/// mode = WILD_ALL:         return all matches concatenated
-/// mode = WILD_LONGEST:     return longest matched part
-/// mode = WILD_ALL_KEEP:    get all matches, keep matches
-///
-/// options = WILD_LIST_NOTFOUND:    list entries without a match
-/// options = WILD_HOME_REPLACE:     do home_replace() for buffer names
-/// options = WILD_USE_NL:           Use '\n' for WILD_ALL
-/// options = WILD_NO_BEEP:          Don't beep for multiple matches
-/// options = WILD_ADD_SLASH:        add a slash after directory names
-/// options = WILD_KEEP_ALL:         don't remove 'wildignore' entries
-/// options = WILD_SILENT:           don't print warning messages
-/// options = WILD_ESCAPE:           put backslash before special chars
-/// options = WILD_ICASE:            ignore case for files
-///
-/// The variables xp->xp_context and xp->xp_backslash must have been set!
-///
-/// @param orig  allocated copy of original of expanded string
-char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode)
-{
-  char_u *ss = NULL;
-  static int findex;
-  static char_u *orig_save = NULL;      // kept value of orig
-  int orig_saved = FALSE;
-  int i;
-  int non_suf_match;                    // number without matching suffix
-
-  /*
-   * first handle the case of using an old match
-   */
-  if (mode == WILD_NEXT || mode == WILD_PREV) {
-    if (xp->xp_numfiles > 0) {
-      if (mode == WILD_PREV) {
-        if (findex == -1) {
-          findex = xp->xp_numfiles;
-        }
-        findex--;
-      } else {  // mode == WILD_NEXT
-        findex++;
-      }
-
-      /*
-       * When wrapping around, return the original string, set findex to
-       * -1.
-       */
-      if (findex < 0) {
-        if (orig_save == NULL) {
-          findex = xp->xp_numfiles - 1;
-        } else {
-          findex = -1;
-        }
-      }
-      if (findex >= xp->xp_numfiles) {
-        if (orig_save == NULL) {
-          findex = 0;
-        } else {
-          findex = -1;
-        }
-      }
-      if (compl_match_array) {
-        compl_selected = findex;
-        cmdline_pum_display(false);
-      } else if (p_wmnu) {
-        redraw_wildmenu(xp, xp->xp_numfiles, xp->xp_files, findex, cmd_showtail);
-      }
-      if (findex == -1) {
-        return vim_strsave(orig_save);
-      }
-      return vim_strsave((char_u *)xp->xp_files[findex]);
-    } else {
-      return NULL;
-    }
-  }
-
-  if (mode == WILD_CANCEL) {
-    ss = vim_strsave(orig_save ? orig_save : (char_u *)"");
-  } else if (mode == WILD_APPLY) {
-    ss =  vim_strsave(findex == -1 ? (orig_save ? orig_save : (char_u *)"") :
-                      (char_u *)xp->xp_files[findex]);
-  }
-
-  // free old names
-  if (xp->xp_numfiles != -1 && mode != WILD_ALL && mode != WILD_LONGEST) {
-    FreeWild(xp->xp_numfiles, xp->xp_files);
-    xp->xp_numfiles = -1;
-    XFREE_CLEAR(orig_save);
-  }
-  findex = 0;
-
-  if (mode == WILD_FREE) {      // only release file name
-    return NULL;
-  }
-
-  if (xp->xp_numfiles == -1 && mode != WILD_APPLY && mode != WILD_CANCEL) {
-    xfree(orig_save);
-    orig_save = orig;
-    orig_saved = TRUE;
-
-    /*
-     * Do the expansion.
-     */
-    if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
-#ifdef FNAME_ILLEGAL
-      /* Illegal file name has been silently skipped.  But when there
-       * are wildcards, the real problem is that there was no match,
-       * causing the pattern to be added, which has illegal characters.
-       */
-      if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND)) {
-        semsg(_(e_nomatch2), str);
-      }
-#endif
-    } else if (xp->xp_numfiles == 0) {
-      if (!(options & WILD_SILENT)) {
-        semsg(_(e_nomatch2), str);
-      }
-    } else {
-      // Escape the matches for use on the command line.
-      ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
-
-      /*
-       * Check for matching suffixes in file names.
-       */
-      if (mode != WILD_ALL && mode != WILD_ALL_KEEP
-          && mode != WILD_LONGEST) {
-        if (xp->xp_numfiles) {
-          non_suf_match = xp->xp_numfiles;
-        } else {
-          non_suf_match = 1;
-        }
-        if ((xp->xp_context == EXPAND_FILES
-             || xp->xp_context == EXPAND_DIRECTORIES)
-            && xp->xp_numfiles > 1) {
-          /*
-           * More than one match; check suffix.
-           * The files will have been sorted on matching suffix in
-           * expand_wildcards, only need to check the first two.
-           */
-          non_suf_match = 0;
-          for (i = 0; i < 2; i++) {
-            if (match_suffix((char_u *)xp->xp_files[i])) {
-              non_suf_match++;
-            }
-          }
-        }
-        if (non_suf_match != 1) {
-          /* Can we ever get here unless it's while expanding
-           * interactively?  If not, we can get rid of this all
-           * together. Don't really want to wait for this message
-           * (and possibly have to hit return to continue!).
-           */
-          if (!(options & WILD_SILENT)) {
-            emsg(_(e_toomany));
-          } else if (!(options & WILD_NO_BEEP)) {
-            beep_flush();
-          }
-        }
-        if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE)) {
-          ss = vim_strsave((char_u *)xp->xp_files[0]);
-        }
-      }
-    }
-  }
-
-  // Find longest common part
-  if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
-    size_t len = 0;
-
-    for (size_t mb_len; xp->xp_files[0][len]; len += mb_len) {
-      mb_len = (size_t)utfc_ptr2len(&xp->xp_files[0][len]);
-      int c0 = utf_ptr2char(&xp->xp_files[0][len]);
-      for (i = 1; i < xp->xp_numfiles; i++) {
-        int ci = utf_ptr2char(&xp->xp_files[i][len]);
-
-        if (p_fic && (xp->xp_context == EXPAND_DIRECTORIES
-                      || xp->xp_context == EXPAND_FILES
-                      || xp->xp_context == EXPAND_SHELLCMD
-                      || xp->xp_context == EXPAND_BUFFERS)) {
-          if (mb_tolower(c0) != mb_tolower(ci)) {
-            break;
-          }
-        } else if (c0 != ci) {
-          break;
-        }
-      }
-      if (i < xp->xp_numfiles) {
-        if (!(options & WILD_NO_BEEP)) {
-          vim_beep(BO_WILD);
-        }
-        break;
-      }
-    }
-
-    ss = (char_u *)xstrndup(xp->xp_files[0], len);
-    findex = -1;  // next p_wc gets first one
-  }
-
-  // Concatenate all matching names
-  // TODO(philix): use xstpcpy instead of strcat in a loop (ExpandOne)
-  if (mode == WILD_ALL && xp->xp_numfiles > 0) {
-    size_t len = 0;
-    for (i = 0; i < xp->xp_numfiles; ++i) {
-      len += STRLEN(xp->xp_files[i]) + 1;
-    }
-    ss = xmalloc(len);
-    *ss = NUL;
-    for (i = 0; i < xp->xp_numfiles; ++i) {
-      STRCAT(ss, xp->xp_files[i]);
-      if (i != xp->xp_numfiles - 1) {
-        STRCAT(ss, (options & WILD_USE_NL) ? "\n" : " ");
-      }
-    }
-  }
-
-  if (mode == WILD_EXPAND_FREE || mode == WILD_ALL) {
-    ExpandCleanup(xp);
-  }
-
-  // Free "orig" if it wasn't stored in "orig_save".
-  if (!orig_saved) {
-    xfree(orig);
-  }
-
-  return ss;
-}
-
-/*
- * Prepare an expand structure for use.
- */
-void ExpandInit(expand_T *xp)
-  FUNC_ATTR_NONNULL_ALL
-{
-  CLEAR_POINTER(xp);
-  xp->xp_backslash = XP_BS_NONE;
-  xp->xp_numfiles = -1;
-}
-
-/*
- * Cleanup an expand structure after use.
- */
-void ExpandCleanup(expand_T *xp)
-{
-  if (xp->xp_numfiles >= 0) {
-    FreeWild(xp->xp_numfiles, xp->xp_files);
-    xp->xp_numfiles = -1;
-  }
-}
-
-void ExpandEscape(expand_T *xp, char_u *str, int numfiles, char **files, int options)
-{
-  int i;
-  char_u *p;
-  const int vse_what = xp->xp_context == EXPAND_BUFFERS ? VSE_BUFFER : VSE_NONE;
-
-  /*
-   * May change home directory back to "~"
-   */
-  if (options & WILD_HOME_REPLACE) {
-    tilde_replace(str, numfiles, files);
-  }
-
-  if (options & WILD_ESCAPE) {
-    if (xp->xp_context == EXPAND_FILES
-        || xp->xp_context == EXPAND_FILES_IN_PATH
-        || xp->xp_context == EXPAND_SHELLCMD
-        || xp->xp_context == EXPAND_BUFFERS
-        || xp->xp_context == EXPAND_DIRECTORIES) {
-      /*
-       * Insert a backslash into a file name before a space, \, %, #
-       * and wildmatch characters, except '~'.
-       */
-      for (i = 0; i < numfiles; ++i) {
-        // for ":set path=" we need to escape spaces twice
-        if (xp->xp_backslash == XP_BS_THREE) {
-          p = vim_strsave_escaped((char_u *)files[i], (char_u *)" ");
-          xfree(files[i]);
-          files[i] = (char *)p;
-#if defined(BACKSLASH_IN_FILENAME)
-          p = vim_strsave_escaped(files[i], (char_u *)" ");
-          xfree(files[i]);
-          files[i] = p;
-#endif
-        }
-#ifdef BACKSLASH_IN_FILENAME
-        p = (char_u *)vim_strsave_fnameescape((const char *)files[i], vse_what);
-#else
-        p = (char_u *)vim_strsave_fnameescape((const char *)files[i],
-                                              xp->xp_shell ? VSE_SHELL : vse_what);
-#endif
-        xfree(files[i]);
-        files[i] = (char *)p;
-
-        /* If 'str' starts with "\~", replace "~" at start of
-         * files[i] with "\~". */
-        if (str[0] == '\\' && str[1] == '~' && files[i][0] == '~') {
-          escape_fname(&files[i]);
-        }
-      }
-      xp->xp_backslash = XP_BS_NONE;
-
-      /* If the first file starts with a '+' escape it.  Otherwise it
-       * could be seen as "+cmd". */
-      if (*files[0] == '+') {
-        escape_fname(&files[0]);
-      }
-    } else if (xp->xp_context == EXPAND_TAGS) {
-      /*
-       * Insert a backslash before characters in a tag name that
-       * would terminate the ":tag" command.
-       */
-      for (i = 0; i < numfiles; i++) {
-        p = vim_strsave_escaped((char_u *)files[i], (char_u *)"\\|\"");
-        xfree(files[i]);
-        files[i] = (char *)p;
-      }
-    }
-  }
-}
-
 /// Escape special characters in "fname", depending on "what":
 ///
 /// @param[in]  fname  File name to escape.
@@ -4576,10 +4009,8 @@ char *vim_strsave_fnameescape(const char *const fname, const int what)
   return p;
 }
 
-/*
- * Put a backslash before the file name in "pp", which is in allocated memory.
- */
-static void escape_fname(char **pp)
+/// Put a backslash before the file name in "pp", which is in allocated memory.
+void escape_fname(char **pp)
 {
   char_u *p = xmalloc(STRLEN(*pp) + 2);
   p[0] = '\\';
@@ -4603,1168 +4034,20 @@ void tilde_replace(char_u *orig_pat, int num_files, char **files)
   }
 }
 
-void cmdline_pum_display(bool changed_array)
-{
-  pum_display(compl_match_array, compl_match_arraysize, compl_selected,
-              changed_array, compl_startcol);
-}
-
-/*
- * Show all matches for completion on the command line.
- * Returns EXPAND_NOTHING when the character that triggered expansion should
- * be inserted like a normal character.
- */
-static int showmatches(expand_T *xp, int wildmenu)
-{
-#define L_SHOWFILE(m) (showtail \
-                       ? sm_gettail(files_found[m], false) : files_found[m])
-  int num_files;
-  char **files_found;
-  int i, j, k;
-  int maxlen;
-  int lines;
-  int columns;
-  char_u *p;
-  int lastlen;
-  int attr;
-  int showtail;
-
-  if (xp->xp_numfiles == -1) {
-    set_expand_context(xp);
-    i = expand_cmdline(xp, ccline.cmdbuff, ccline.cmdpos,
-                       &num_files, &files_found);
-    showtail = expand_showtail(xp);
-    if (i != EXPAND_OK) {
-      return i;
-    }
-  } else {
-    num_files = xp->xp_numfiles;
-    files_found = xp->xp_files;
-    showtail = cmd_showtail;
-  }
-
-  bool compl_use_pum = (ui_has(kUICmdline)
-                        ? ui_has(kUIPopupmenu)
-                        : wildmenu && (wop_flags & WOP_PUM))
-                       || ui_has(kUIWildmenu);
-
-  if (compl_use_pum) {
-    assert(num_files >= 0);
-    compl_match_arraysize = num_files;
-    compl_match_array = xcalloc((size_t)compl_match_arraysize,
-                                sizeof(pumitem_T));
-    for (i = 0; i < num_files; i++) {
-      compl_match_array[i].pum_text = (char_u *)L_SHOWFILE(i);
-    }
-    char_u *endpos = (char_u *)(showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
-    if (ui_has(kUICmdline)) {
-      compl_startcol = (int)(endpos - ccline.cmdbuff);
-    } else {
-      compl_startcol = cmd_screencol((int)(endpos - ccline.cmdbuff));
-    }
-    compl_selected = -1;
-    cmdline_pum_display(true);
-    return EXPAND_OK;
-  }
-
-  if (!wildmenu) {
-    msg_didany = false;                 // lines_left will be set
-    msg_start();                        // prepare for paging
-    msg_putchar('\n');
-    ui_flush();
-    cmdline_row = msg_row;
-    msg_didany = false;                 // lines_left will be set again
-    msg_start();                        // prepare for paging
-  }
-
-  if (got_int) {
-    got_int = false;            // only int. the completion, not the cmd line
-  } else if (wildmenu) {
-    redraw_wildmenu(xp, num_files, files_found, -1, showtail);
-  } else {
-    // find the length of the longest file name
-    maxlen = 0;
-    for (i = 0; i < num_files; ++i) {
-      if (!showtail && (xp->xp_context == EXPAND_FILES
-                        || xp->xp_context == EXPAND_SHELLCMD
-                        || xp->xp_context == EXPAND_BUFFERS)) {
-        home_replace(NULL, files_found[i], (char *)NameBuff, MAXPATHL, true);
-        j = vim_strsize((char *)NameBuff);
-      } else {
-        j = vim_strsize(L_SHOWFILE(i));
-      }
-      if (j > maxlen) {
-        maxlen = j;
-      }
-    }
-
-    if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
-      lines = num_files;
-    } else {
-      // compute the number of columns and lines for the listing
-      maxlen += 2;          // two spaces between file names
-      columns = (Columns + 2) / maxlen;
-      if (columns < 1) {
-        columns = 1;
-      }
-      lines = (num_files + columns - 1) / columns;
-    }
-
-    attr = HL_ATTR(HLF_D);      // find out highlighting for directories
-
-    if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
-      msg_puts_attr(_("tagname"), HL_ATTR(HLF_T));
-      msg_clr_eos();
-      msg_advance(maxlen - 3);
-      msg_puts_attr(_(" kind file\n"), HL_ATTR(HLF_T));
-    }
-
-    // list the files line by line
-    for (i = 0; i < lines; ++i) {
-      lastlen = 999;
-      for (k = i; k < num_files; k += lines) {
-        if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
-          msg_outtrans_attr((char_u *)files_found[k], HL_ATTR(HLF_D));
-          p = (char_u *)files_found[k] + STRLEN(files_found[k]) + 1;
-          msg_advance(maxlen + 1);
-          msg_puts((const char *)p);
-          msg_advance(maxlen + 3);
-          msg_outtrans_long_attr(p + 2, HL_ATTR(HLF_D));
-          break;
-        }
-        for (j = maxlen - lastlen; --j >= 0;) {
-          msg_putchar(' ');
-        }
-        if (xp->xp_context == EXPAND_FILES
-            || xp->xp_context == EXPAND_SHELLCMD
-            || xp->xp_context == EXPAND_BUFFERS) {
-          // highlight directories
-          if (xp->xp_numfiles != -1) {
-            // Expansion was done before and special characters
-            // were escaped, need to halve backslashes.  Also
-            // $HOME has been replaced with ~/.
-            char_u *exp_path = expand_env_save_opt((char_u *)files_found[k], true);
-            char_u *path = exp_path != NULL ? exp_path : (char_u *)files_found[k];
-            char_u *halved_slash = backslash_halve_save(path);
-            j = os_isdir(halved_slash);
-            xfree(exp_path);
-            if (halved_slash != path) {
-              xfree(halved_slash);
-            }
-          } else {
-            // Expansion was done here, file names are literal.
-            j = os_isdir((char_u *)files_found[k]);
-          }
-          if (showtail) {
-            p = (char_u *)L_SHOWFILE(k);
-          } else {
-            home_replace(NULL, files_found[k], (char *)NameBuff, MAXPATHL, true);
-            p = NameBuff;
-          }
-        } else {
-          j = false;
-          p = (char_u *)L_SHOWFILE(k);
-        }
-        lastlen = msg_outtrans_attr(p, j ? attr : 0);
-      }
-      if (msg_col > 0) {        // when not wrapped around
-        msg_clr_eos();
-        msg_putchar('\n');
-      }
-      ui_flush();                          // show one line at a time
-      if (got_int) {
-        got_int = FALSE;
-        break;
-      }
-    }
-
-    /*
-     * we redraw the command below the lines that we have just listed
-     * This is a bit tricky, but it saves a lot of screen updating.
-     */
-    cmdline_row = msg_row;      // will put it back later
-  }
-
-  if (xp->xp_numfiles == -1) {
-    FreeWild(num_files, files_found);
-  }
-
-  return EXPAND_OK;
-}
-
-/// Private path_tail for showmatches() (and redraw_wildmenu()):
-/// Find tail of file name path, but ignore trailing "/".
-char *sm_gettail(char *s, bool eager)
-{
-  char_u *p;
-  char_u *t = (char_u *)s;
-  int had_sep = false;
-
-  for (p = (char_u *)s; *p != NUL;) {
-    if (vim_ispathsep(*p)
-#ifdef BACKSLASH_IN_FILENAME
-        && !rem_backslash(p)
-#endif
-        ) {
-      if (eager) {
-        t = p + 1;
-      } else {
-        had_sep = true;
-      }
-    } else if (had_sep) {
-      t = p;
-      had_sep = FALSE;
-    }
-    MB_PTR_ADV(p);
-  }
-  return (char *)t;
-}
-
-/*
- * Return TRUE if we only need to show the tail of completion matches.
- * When not completing file names or there is a wildcard in the path FALSE is
- * returned.
- */
-static int expand_showtail(expand_T *xp)
-{
-  char_u *s;
-  char_u *end;
-
-  // When not completing file names a "/" may mean something different.
-  if (xp->xp_context != EXPAND_FILES
-      && xp->xp_context != EXPAND_SHELLCMD
-      && xp->xp_context != EXPAND_DIRECTORIES) {
-    return FALSE;
-  }
-
-  end = (char_u *)path_tail(xp->xp_pattern);
-  if (end == (char_u *)xp->xp_pattern) {          // there is no path separator
-    return false;
-  }
-
-  for (s = (char_u *)xp->xp_pattern; s < end; s++) {
-    // Skip escaped wildcards.  Only when the backslash is not a path
-    // separator, on DOS the '*' "path\*\file" must not be skipped.
-    if (rem_backslash(s)) {
-      s++;
-    } else if (vim_strchr("*?[", *s) != NULL) {
-      return false;
-    }
-  }
-  return TRUE;
-}
-
-/// Prepare a string for expansion.
-///
-/// When expanding file names: The string will be used with expand_wildcards().
-/// Copy "fname[len]" into allocated memory and add a '*' at the end.
-/// When expanding other names: The string will be used with regcomp().  Copy
-/// the name into allocated memory and prepend "^".
-///
-/// @param context EXPAND_FILES etc.
-char_u *addstar(char_u *fname, size_t len, int context)
-  FUNC_ATTR_NONNULL_RET
-{
-  char_u *retval;
-  size_t i, j;
-  size_t new_len;
-  char_u *tail;
-  int ends_in_star;
-
-  if (context != EXPAND_FILES
-      && context != EXPAND_FILES_IN_PATH
-      && context != EXPAND_SHELLCMD
-      && context != EXPAND_DIRECTORIES) {
-    /*
-     * Matching will be done internally (on something other than files).
-     * So we convert the file-matching-type wildcards into our kind for
-     * use with vim_regcomp().  First work out how long it will be:
-     */
-
-    // For help tags the translation is done in find_help_tags().
-    // For a tag pattern starting with "/" no translation is needed.
-    if (context == EXPAND_HELP
-        || context == EXPAND_CHECKHEALTH
-        || context == EXPAND_COLORS
-        || context == EXPAND_COMPILER
-        || context == EXPAND_OWNSYNTAX
-        || context == EXPAND_FILETYPE
-        || context == EXPAND_PACKADD
-        || ((context == EXPAND_TAGS_LISTFILES || context == EXPAND_TAGS)
-            && fname[0] == '/')) {
-      retval = vim_strnsave(fname, len);
-    } else {
-      new_len = len + 2;                // +2 for '^' at start, NUL at end
-      for (i = 0; i < len; i++) {
-        if (fname[i] == '*' || fname[i] == '~') {
-          new_len++;                    /* '*' needs to be replaced by ".*"
-                                           '~' needs to be replaced by "\~" */
-        }
-        // Buffer names are like file names.  "." should be literal
-        if (context == EXPAND_BUFFERS && fname[i] == '.') {
-          new_len++;                    // "." becomes "\."
-        }
-        /* Custom expansion takes care of special things, match
-         * backslashes literally (perhaps also for other types?) */
-        if ((context == EXPAND_USER_DEFINED
-             || context == EXPAND_USER_LIST) && fname[i] == '\\') {
-          new_len++;                    // '\' becomes "\\"
-        }
-      }
-      retval = xmalloc(new_len);
-      {
-        retval[0] = '^';
-        j = 1;
-        for (i = 0; i < len; i++, j++) {
-          /* Skip backslash.  But why?  At least keep it for custom
-           * expansion. */
-          if (context != EXPAND_USER_DEFINED
-              && context != EXPAND_USER_LIST
-              && fname[i] == '\\'
-              && ++i == len) {
-            break;
-          }
-
-          switch (fname[i]) {
-          case '*':
-            retval[j++] = '.';
-            break;
-          case '~':
-            retval[j++] = '\\';
-            break;
-          case '?':
-            retval[j] = '.';
-            continue;
-          case '.':
-            if (context == EXPAND_BUFFERS) {
-              retval[j++] = '\\';
-            }
-            break;
-          case '\\':
-            if (context == EXPAND_USER_DEFINED
-                || context == EXPAND_USER_LIST) {
-              retval[j++] = '\\';
-            }
-            break;
-          }
-          retval[j] = fname[i];
-        }
-        retval[j] = NUL;
-      }
-    }
-  } else {
-    retval = xmalloc(len + 4);
-    STRLCPY(retval, fname, len + 1);
-
-    /*
-     * Don't add a star to *, ~, ~user, $var or `cmd`.
-     * * would become **, which walks the whole tree.
-     * ~ would be at the start of the file name, but not the tail.
-     * $ could be anywhere in the tail.
-     * ` could be anywhere in the file name.
-     * When the name ends in '$' don't add a star, remove the '$'.
-     */
-    tail = (char_u *)path_tail((char *)retval);
-    ends_in_star = (len > 0 && retval[len - 1] == '*');
-#ifndef BACKSLASH_IN_FILENAME
-    for (ssize_t k = (ssize_t)len - 2; k >= 0; k--) {
-      if (retval[k] != '\\') {
-        break;
-      }
-      ends_in_star = !ends_in_star;
-    }
-#endif
-    if ((*retval != '~' || tail != retval)
-        && !ends_in_star
-        && vim_strchr((char *)tail, '$') == NULL
-        && vim_strchr((char *)retval, '`') == NULL) {
-      retval[len++] = '*';
-    } else if (len > 0 && retval[len - 1] == '$') {
-      len--;
-    }
-    retval[len] = NUL;
-  }
-  return retval;
-}
-
-/*
- * Must parse the command line so far to work out what context we are in.
- * Completion can then be done based on that context.
- * This routine sets the variables:
- *  xp->xp_pattern          The start of the pattern to be expanded within
- *                              the command line (ends at the cursor).
- *  xp->xp_context          The type of thing to expand.  Will be one of:
- *
- *  EXPAND_UNSUCCESSFUL     Used sometimes when there is something illegal on
- *                          the command line, like an unknown command.  Caller
- *                          should beep.
- *  EXPAND_NOTHING          Unrecognised context for completion, use char like
- *                          a normal char, rather than for completion.  eg
- *                          :s/^I/
- *  EXPAND_COMMANDS         Cursor is still touching the command, so complete
- *                          it.
- *  EXPAND_BUFFERS          Complete file names for :buf and :sbuf commands.
- *  EXPAND_FILES            After command with EX_XFILE set, or after setting
- *                          with P_EXPAND set.  eg :e ^I, :w>>^I
- *  EXPAND_DIRECTORIES      In some cases this is used instead of the latter
- *                          when we know only directories are of interest.  eg
- *                          :set dir=^I
- *  EXPAND_SHELLCMD         After ":!cmd", ":r !cmd"  or ":w !cmd".
- *  EXPAND_SETTINGS         Complete variable names.  eg :set d^I
- *  EXPAND_BOOL_SETTINGS    Complete boolean variables only,  eg :set no^I
- *  EXPAND_TAGS             Complete tags from the files in p_tags.  eg :ta a^I
- *  EXPAND_TAGS_LISTFILES   As above, but list filenames on ^D, after :tselect
- *  EXPAND_HELP             Complete tags from the file 'helpfile'/tags
- *  EXPAND_EVENTS           Complete event names
- *  EXPAND_SYNTAX           Complete :syntax command arguments
- *  EXPAND_HIGHLIGHT        Complete highlight (syntax) group names
- *  EXPAND_AUGROUP          Complete autocommand group names
- *  EXPAND_USER_VARS        Complete user defined variable names, eg :unlet a^I
- *  EXPAND_MAPPINGS         Complete mapping and abbreviation names,
- *                            eg :unmap a^I , :cunab x^I
- *  EXPAND_FUNCTIONS        Complete internal or user defined function names,
- *                            eg :call sub^I
- *  EXPAND_USER_FUNC        Complete user defined function names, eg :delf F^I
- *  EXPAND_EXPRESSION       Complete internal or user defined function/variable
- *                          names in expressions, eg :while s^I
- *  EXPAND_ENV_VARS         Complete environment variable names
- *  EXPAND_USER             Complete user names
- */
-void set_expand_context(expand_T *xp)
-{
-  // only expansion for ':', '>' and '=' command-lines
-  if (ccline.cmdfirstc != ':'
-      && ccline.cmdfirstc != '>' && ccline.cmdfirstc != '='
-      && !ccline.input_fn) {
-    xp->xp_context = EXPAND_NOTHING;
-    return;
-  }
-  set_cmd_context(xp, ccline.cmdbuff, ccline.cmdlen, ccline.cmdpos, true);
-}
-
-/// @param str  start of command line
-/// @param len  length of command line (excl. NUL)
-/// @param col  position of cursor
-/// @param use_ccline  use ccline for info
-void set_cmd_context(expand_T *xp, char_u *str, int len, int col, int use_ccline)
-{
-  char_u old_char = NUL;
-
-  /*
-   * Avoid a UMR warning from Purify, only save the character if it has been
-   * written before.
-   */
-  if (col < len) {
-    old_char = str[col];
-  }
-  str[col] = NUL;
-  const char *nextcomm = (const char *)str;
-
-  if (use_ccline && ccline.cmdfirstc == '=') {
-    // pass CMD_SIZE because there is no real command
-    set_context_for_expression(xp, (char *)str, CMD_SIZE);
-  } else if (use_ccline && ccline.input_fn) {
-    xp->xp_context = ccline.xp_context;
-    xp->xp_pattern = (char *)ccline.cmdbuff;
-    xp->xp_arg = (char *)ccline.xp_arg;
-  } else {
-    while (nextcomm != NULL) {
-      nextcomm = set_one_cmd_context(xp, nextcomm);
-    }
-  }
-
-  /* Store the string here so that call_user_expand_func() can get to them
-   * easily. */
-  xp->xp_line = (char *)str;
-  xp->xp_col = col;
-
-  str[col] = old_char;
-}
-
-/// Expand the command line "str" from context "xp".
-/// "xp" must have been set by set_cmd_context().
-/// xp->xp_pattern points into "str", to where the text that is to be expanded
-/// starts.
-/// Returns EXPAND_UNSUCCESSFUL when there is something illegal before the
-/// cursor.
-/// Returns EXPAND_NOTHING when there is nothing to expand, might insert the
-/// key that triggered expansion literally.
-/// Returns EXPAND_OK otherwise.
-///
-/// @param str  start of command line
-/// @param col  position of cursor
-/// @param matchcount  return: nr of matches
-/// @param matches  return: array of pointers to matches
-int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***matches)
-{
-  char_u *file_str = NULL;
-  int options = WILD_ADD_SLASH|WILD_SILENT;
-
-  if (xp->xp_context == EXPAND_UNSUCCESSFUL) {
-    beep_flush();
-    return EXPAND_UNSUCCESSFUL;      // Something illegal on command line
-  }
-  if (xp->xp_context == EXPAND_NOTHING) {
-    // Caller can use the character as a normal char instead
-    return EXPAND_NOTHING;
-  }
-
-  // add star to file name, or convert to regexp if not exp. files.
-  assert((str + col) - (char_u *)xp->xp_pattern >= 0);
-  xp->xp_pattern_len = (size_t)((str + col) - (char_u *)xp->xp_pattern);
-  file_str = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
-
-  if (p_wic) {
-    options += WILD_ICASE;
-  }
-
-  // find all files that match the description
-  if (ExpandFromContext(xp, file_str, matchcount, matches, options) == FAIL) {
-    *matchcount = 0;
-    *matches = NULL;
-  }
-  xfree(file_str);
-
-  return EXPAND_OK;
-}
-
-typedef char *(*ExpandFunc)(expand_T *, int);
-
-/// Do the expansion based on xp->xp_context and "pat".
-///
-/// @param options  WILD_ flags
-static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***file, int options)
-{
-  regmatch_T regmatch;
-  int ret;
-  int flags;
-
-  flags = EW_DIR;       // include directories
-  if (options & WILD_LIST_NOTFOUND) {
-    flags |= EW_NOTFOUND;
-  }
-  if (options & WILD_ADD_SLASH) {
-    flags |= EW_ADDSLASH;
-  }
-  if (options & WILD_KEEP_ALL) {
-    flags |= EW_KEEPALL;
-  }
-  if (options & WILD_SILENT) {
-    flags |= EW_SILENT;
-  }
-  if (options & WILD_NOERROR) {
-    flags |= EW_NOERROR;
-  }
-  if (options & WILD_ALLLINKS) {
-    flags |= EW_ALLLINKS;
-  }
-
-  if (xp->xp_context == EXPAND_FILES
-      || xp->xp_context == EXPAND_DIRECTORIES
-      || xp->xp_context == EXPAND_FILES_IN_PATH) {
-    /*
-     * Expand file or directory names.
-     */
-    int free_pat = FALSE;
-    int i;
-
-    // for ":set path=" and ":set tags=" halve backslashes for escaped space
-    if (xp->xp_backslash != XP_BS_NONE) {
-      free_pat = TRUE;
-      pat = vim_strsave(pat);
-      for (i = 0; pat[i]; ++i) {
-        if (pat[i] == '\\') {
-          if (xp->xp_backslash == XP_BS_THREE
-              && pat[i + 1] == '\\'
-              && pat[i + 2] == '\\'
-              && pat[i + 3] == ' ') {
-            STRMOVE(pat + i, pat + i + 3);
-          }
-          if (xp->xp_backslash == XP_BS_ONE
-              && pat[i + 1] == ' ') {
-            STRMOVE(pat + i, pat + i + 1);
-          }
-        }
-      }
-    }
-
-    if (xp->xp_context == EXPAND_FILES) {
-      flags |= EW_FILE;
-    } else if (xp->xp_context == EXPAND_FILES_IN_PATH) {
-      flags |= (EW_FILE | EW_PATH);
-    } else {
-      flags = (flags | EW_DIR) & ~EW_FILE;
-    }
-    if (options & WILD_ICASE) {
-      flags |= EW_ICASE;
-    }
-
-    // Expand wildcards, supporting %:h and the like.
-    ret = expand_wildcards_eval(&pat, num_file, file, flags);
-    if (free_pat) {
-      xfree(pat);
-    }
-#ifdef BACKSLASH_IN_FILENAME
-    if (p_csl[0] != NUL && (options & WILD_IGNORE_COMPLETESLASH) == 0) {
-      for (int i = 0; i < *num_file; i++) {
-        char_u *ptr = (*file)[i];
-        while (*ptr != NUL) {
-          if (p_csl[0] == 's' && *ptr == '\\') {
-            *ptr = '/';
-          } else if (p_csl[0] == 'b' && *ptr == '/') {
-            *ptr = '\\';
-          }
-          ptr += utfc_ptr2len(ptr);
-        }
-      }
-    }
-#endif
-    return ret;
-  }
-
-  *file = NULL;
-  *num_file = 0;
-  if (xp->xp_context == EXPAND_HELP) {
-    /* With an empty argument we would get all the help tags, which is
-     * very slow.  Get matches for "help" instead. */
-    if (find_help_tags(*pat == NUL ? "help" : (char *)pat,
-                       num_file, file, false) == OK) {
-      cleanup_help_tags(*num_file, *file);
-      return OK;
-    }
-    return FAIL;
-  }
-
-  if (xp->xp_context == EXPAND_SHELLCMD) {
-    *file = NULL;
-    expand_shellcmd(pat, num_file, file, flags);
-    return OK;
-  }
-  if (xp->xp_context == EXPAND_OLD_SETTING) {
-    ExpandOldSetting(num_file, file);
-    return OK;
-  }
-  if (xp->xp_context == EXPAND_BUFFERS) {
-    return ExpandBufnames((char *)pat, num_file, file, options);
-  }
-  if (xp->xp_context == EXPAND_DIFF_BUFFERS) {
-    return ExpandBufnames((char *)pat, num_file, file, options | BUF_DIFF_FILTER);
-  }
-  if (xp->xp_context == EXPAND_TAGS
-      || xp->xp_context == EXPAND_TAGS_LISTFILES) {
-    return expand_tags(xp->xp_context == EXPAND_TAGS, pat, num_file, file);
-  }
-  if (xp->xp_context == EXPAND_COLORS) {
-    char *directories[] = { "colors", NULL };
-    return ExpandRTDir(pat, DIP_START + DIP_OPT + DIP_LUA, num_file, file, directories);
-  }
-  if (xp->xp_context == EXPAND_COMPILER) {
-    char *directories[] = { "compiler", NULL };
-    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
-  }
-  if (xp->xp_context == EXPAND_OWNSYNTAX) {
-    char *directories[] = { "syntax", NULL };
-    return ExpandRTDir(pat, 0, num_file, file, directories);
-  }
-  if (xp->xp_context == EXPAND_FILETYPE) {
-    char *directories[] = { "syntax", "indent", "ftplugin", NULL };
-    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
-  }
-  if (xp->xp_context == EXPAND_USER_LIST) {
-    return ExpandUserList(xp, num_file, file);
-  }
-  if (xp->xp_context == EXPAND_USER_LUA) {
-    return ExpandUserLua(xp, num_file, file);
-  }
-  if (xp->xp_context == EXPAND_PACKADD) {
-    return ExpandPackAddDir(pat, num_file, file);
-  }
-
-  // When expanding a function name starting with s:, match the <SNR>nr_
-  // prefix.
-  char *tofree = NULL;
-  if (xp->xp_context == EXPAND_USER_FUNC && STRNCMP(pat, "^s:", 3) == 0) {
-    const size_t len = STRLEN(pat) + 20;
-
-    tofree = xmalloc(len);
-    snprintf(tofree, len, "^<SNR>\\d\\+_%s", pat + 3);
-    pat = (char_u *)tofree;
-  }
-
-  if (xp->xp_context == EXPAND_LUA) {
-    ILOG("PAT %s", pat);
-    return nlua_expand_pat(xp, pat, num_file, file);
-  }
-
-  regmatch.regprog = vim_regcomp((char *)pat, p_magic ? RE_MAGIC : 0);
-  if (regmatch.regprog == NULL) {
-    return FAIL;
-  }
-
-  // set ignore-case according to p_ic, p_scs and pat
-  regmatch.rm_ic = ignorecase(pat);
-
-  if (xp->xp_context == EXPAND_SETTINGS
-      || xp->xp_context == EXPAND_BOOL_SETTINGS) {
-    ret = ExpandSettings(xp, &regmatch, num_file, file);
-  } else if (xp->xp_context == EXPAND_MAPPINGS) {
-    ret = ExpandMappings(&regmatch, num_file, file);
-  } else if (xp->xp_context == EXPAND_USER_DEFINED) {
-    ret = ExpandUserDefined(xp, &regmatch, num_file, file);
-  } else {
-    static struct expgen {
-      int context;
-      ExpandFunc func;
-      int ic;
-      int escaped;
-    } tab[] = {
-      { EXPAND_COMMANDS, get_command_name, false, true },
-      { EXPAND_BEHAVE, get_behave_arg, true, true },
-      { EXPAND_MAPCLEAR, get_mapclear_arg, true, true },
-      { EXPAND_MESSAGES, get_messages_arg, true, true },
-      { EXPAND_HISTORY, get_history_arg, true, true },
-      { EXPAND_USER_COMMANDS, get_user_commands, false, true },
-      { EXPAND_USER_ADDR_TYPE, get_user_cmd_addr_type, false, true },
-      { EXPAND_USER_CMD_FLAGS, get_user_cmd_flags, false, true },
-      { EXPAND_USER_NARGS, get_user_cmd_nargs, false, true },
-      { EXPAND_USER_COMPLETE, get_user_cmd_complete, false, true },
-      { EXPAND_USER_VARS, get_user_var_name, false, true },
-      { EXPAND_FUNCTIONS, get_function_name, false, true },
-      { EXPAND_USER_FUNC, get_user_func_name, false, true },
-      { EXPAND_EXPRESSION, get_expr_name, false, true },
-      { EXPAND_MENUS, get_menu_name, false, true },
-      { EXPAND_MENUNAMES, get_menu_names, false, true },
-      { EXPAND_SYNTAX, get_syntax_name, true, true },
-      { EXPAND_SYNTIME, get_syntime_arg, true, true },
-      { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, true },
-      { EXPAND_EVENTS, expand_get_event_name, true, false },
-      { EXPAND_AUGROUP, expand_get_augroup_name, true, false },
-      { EXPAND_CSCOPE, get_cscope_name, true, true },
-      { EXPAND_SIGN, get_sign_name, true, true },
-      { EXPAND_PROFILE, get_profile_name, true, true },
-#ifdef HAVE_WORKING_LIBINTL
-      { EXPAND_LANGUAGE, get_lang_arg, true, false },
-      { EXPAND_LOCALES, get_locales, true, false },
-#endif
-      { EXPAND_ENV_VARS, get_env_name, true, true },
-      { EXPAND_USER, get_users, true, false },
-      { EXPAND_ARGLIST, get_arglist_name, true, false },
-      { EXPAND_CHECKHEALTH, get_healthcheck_names, true, false },
-    };
-    int i;
-
-    /*
-     * Find a context in the table and call the ExpandGeneric() with the
-     * right function to do the expansion.
-     */
-    ret = FAIL;
-    for (i = 0; i < (int)ARRAY_SIZE(tab); ++i) {
-      if (xp->xp_context == tab[i].context) {
-        if (tab[i].ic) {
-          regmatch.rm_ic = TRUE;
-        }
-        ExpandGeneric(xp, &regmatch, num_file, file, tab[i].func, tab[i].escaped);
-        ret = OK;
-        break;
-      }
-    }
-  }
-
-  vim_regfree(regmatch.regprog);
-  xfree(tofree);
-
-  return ret;
-}
-
-/// Expand a list of names.
-///
-/// Generic function for command line completion.  It calls a function to
-/// obtain strings, one by one.  The strings are matched against a regexp
-/// program.  Matching strings are copied into an array, which is returned.
-///
-/// @param func  returns a string from the list
-static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file,
-                          CompleteListItemGetter func, int escaped)
-{
-  int i;
-  size_t count = 0;
-  char_u *str;
-
-  // count the number of matching names
-  for (i = 0;; i++) {
-    str = (char_u *)(*func)(xp, i);
-    if (str == NULL) {  // end of list
-      break;
-    }
-    if (*str == NUL) {  // skip empty strings
-      continue;
-    }
-    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
-      count++;
-    }
-  }
-  if (count == 0) {
-    return;
-  }
-  assert(count < INT_MAX);
-  *num_file = (int)count;
-  *file = xmalloc(count * sizeof(char_u *));
-
-  // copy the matching names into allocated memory
-  count = 0;
-  for (i = 0;; i++) {
-    str = (char_u *)(*func)(xp, i);
-    if (str == NULL) {  // End of list.
-      break;
-    }
-    if (*str == NUL) {  // Skip empty strings.
-      continue;
-    }
-    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
-      if (escaped) {
-        str = vim_strsave_escaped(str, (char_u *)" \t\\.");
-      } else {
-        str = vim_strsave(str);
-      }
-      (*file)[count++] = (char *)str;
-      if (func == get_menu_names) {
-        // Test for separator added by get_menu_names().
-        str += STRLEN(str) - 1;
-        if (*str == '\001') {
-          *str = '.';
-        }
-      }
-    }
-  }
-
-  // Sort the results.  Keep menu's in the specified order.
-  if (xp->xp_context != EXPAND_MENUNAMES && xp->xp_context != EXPAND_MENUS) {
-    if (xp->xp_context == EXPAND_EXPRESSION
-        || xp->xp_context == EXPAND_FUNCTIONS
-        || xp->xp_context == EXPAND_USER_FUNC) {
-      // <SNR> functions should be sorted to the end.
-      qsort((void *)*file, (size_t)*num_file, sizeof(char_u *),
-            sort_func_compare);
-    } else {
-      sort_strings(*file, *num_file);
-    }
-  }
-
-  /* Reset the variables used for special highlight names expansion, so that
-   * they don't show up when getting normal highlight names by ID. */
-  reset_expand_highlight();
-}
-
-/// Complete a shell command.
-///
-/// @param      filepat  is a pattern to match with command names.
-/// @param[out] num_file is pointer to number of matches.
-/// @param[out] file     is pointer to array of pointers to matches.
-///                      *file will either be set to NULL or point to
-///                      allocated memory.
-/// @param      flagsarg is a combination of EW_* flags.
-static void expand_shellcmd(char_u *filepat, int *num_file, char ***file, int flagsarg)
-  FUNC_ATTR_NONNULL_ALL
+/// Get a pointer to the current command line info.
+CmdlineInfo *get_cmdline_info(void)
 {
-  char_u *pat;
-  int i;
-  char_u *path = NULL;
-  garray_T ga;
-  char *buf = xmalloc(MAXPATHL);
-  size_t l;
-  char_u *s, *e;
-  int flags = flagsarg;
-  int ret;
-  bool did_curdir = false;
-
-  // for ":set path=" and ":set tags=" halve backslashes for escaped space
-  pat = vim_strsave(filepat);
-  for (i = 0; pat[i]; ++i) {
-    if (pat[i] == '\\' && pat[i + 1] == ' ') {
-      STRMOVE(pat + i, pat + i + 1);
-    }
-  }
-
-  flags |= EW_FILE | EW_EXEC | EW_SHELLCMD;
-
-  bool mustfree = false;  // Track memory allocation for *path.
-  if (pat[0] == '.' && (vim_ispathsep(pat[1])
-                        || (pat[1] == '.' && vim_ispathsep(pat[2])))) {
-    path = (char_u *)".";
-  } else {
-    // For an absolute name we don't use $PATH.
-    if (!path_is_absolute(pat)) {
-      path = (char_u *)vim_getenv("PATH");
-    }
-    if (path == NULL) {
-      path = (char_u *)"";
-    } else {
-      mustfree = true;
-    }
-  }
-
-  /*
-   * Go over all directories in $PATH.  Expand matches in that directory and
-   * collect them in "ga". When "." is not in $PATH also expaned for the
-   * current directory, to find "subdir/cmd".
-   */
-  ga_init(&ga, (int)sizeof(char *), 10);
-  hashtab_T found_ht;
-  hash_init(&found_ht);
-  for (s = path;; s = e) {
-    e = (char_u *)vim_strchr((char *)s, ENV_SEPCHAR);
-    if (e == NULL) {
-      e = s + STRLEN(s);
-    }
-
-    if (*s == NUL) {
-      if (did_curdir) {
-        break;
-      }
-      // Find directories in the current directory, path is empty.
-      did_curdir = true;
-      flags |= EW_DIR;
-    } else if (STRNCMP(s, ".", e - s) == 0) {
-      did_curdir = true;
-      flags |= EW_DIR;
-    } else {
-      // Do not match directories inside a $PATH item.
-      flags &= ~EW_DIR;
-    }
-
-    l = (size_t)(e - s);
-    if (l > MAXPATHL - 5) {
-      break;
-    }
-    STRLCPY(buf, s, l + 1);
-    add_pathsep(buf);
-    l = STRLEN(buf);
-    STRLCPY(buf + l, pat, MAXPATHL - l);
-
-    // Expand matches in one directory of $PATH.
-    ret = expand_wildcards(1, &buf, num_file, file, flags);
-    if (ret == OK) {
-      ga_grow(&ga, *num_file);
-      {
-        for (i = 0; i < *num_file; i++) {
-          char_u *name = (char_u *)(*file)[i];
-
-          if (STRLEN(name) > l) {
-            // Check if this name was already found.
-            hash_T hash = hash_hash(name + l);
-            hashitem_T *hi =
-              hash_lookup(&found_ht, (const char *)(name + l),
-                          STRLEN(name + l), hash);
-            if (HASHITEM_EMPTY(hi)) {
-              // Remove the path that was prepended.
-              STRMOVE(name, name + l);
-              ((char_u **)ga.ga_data)[ga.ga_len++] = name;
-              hash_add_item(&found_ht, hi, name, hash);
-              name = NULL;
-            }
-          }
-          xfree(name);
-        }
-        xfree(*file);
-      }
-    }
-    if (*e != NUL) {
-      e++;
-    }
-  }
-  *file = ga.ga_data;
-  *num_file = ga.ga_len;
-
-  xfree(buf);
-  xfree(pat);
-  if (mustfree) {
-    xfree(path);
-  }
-  hash_clear(&found_ht);
-}
-
-/// Call "user_expand_func()" to invoke a user defined Vim script function and
-/// return the result (either a string, a List or NULL).
-static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T *xp, int *num_file,
-                                   char ***file)
-  FUNC_ATTR_NONNULL_ALL
-{
-  char_u keep = 0;
-  typval_T args[4];
-  char_u *pat = NULL;
-  const sctx_T save_current_sctx = current_sctx;
-
-  if (xp->xp_arg == NULL || xp->xp_arg[0] == '\0' || xp->xp_line == NULL) {
-    return NULL;
-  }
-  *num_file = 0;
-  *file = NULL;
-
-  if (ccline.cmdbuff != NULL) {
-    keep = ccline.cmdbuff[ccline.cmdlen];
-    ccline.cmdbuff[ccline.cmdlen] = 0;
-  }
-
-  pat = vim_strnsave((char_u *)xp->xp_pattern, xp->xp_pattern_len);
-  args[0].v_type = VAR_STRING;
-  args[1].v_type = VAR_STRING;
-  args[2].v_type = VAR_NUMBER;
-  args[3].v_type = VAR_UNKNOWN;
-  args[0].vval.v_string = (char *)pat;
-  args[1].vval.v_string = xp->xp_line;
-  args[2].vval.v_number = xp->xp_col;
-
-  current_sctx = xp->xp_script_ctx;
-
-  void *const ret = user_expand_func((char_u *)xp->xp_arg, 3, args);
-
-  current_sctx = save_current_sctx;
-  if (ccline.cmdbuff != NULL) {
-    ccline.cmdbuff[ccline.cmdlen] = keep;
-  }
-
-  xfree(pat);
-  return ret;
-}
-
-/// Expand names with a function defined by the user.
-static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file)
-{
-  char_u *e;
-  garray_T ga;
-
-  char_u *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
-                                               file);
-
-  if (retstr == NULL) {
-    return FAIL;
-  }
-
-  ga_init(&ga, (int)sizeof(char *), 3);
-  for (char_u *s = retstr; *s != NUL; s = e) {
-    e = (char_u *)vim_strchr((char *)s, '\n');
-    if (e == NULL) {
-      e = s + STRLEN(s);
-    }
-    const char_u keep = *e;
-    *e = NUL;
-
-    const bool skip = xp->xp_pattern[0]
-                      && vim_regexec(regmatch, (char *)s, (colnr_T)0) == 0;
-    *e = keep;
-    if (!skip) {
-      GA_APPEND(char_u *, &ga, vim_strnsave(s, (size_t)(e - s)));
-    }
-
-    if (*e != NUL) {
-      e++;
-    }
-  }
-  xfree(retstr);
-  *file = ga.ga_data;
-  *num_file = ga.ga_len;
-  return OK;
-}
-
-/// Expand names with a list returned by a function defined by the user.
-static int ExpandUserList(expand_T *xp, int *num_file, char ***file)
-{
-  list_T *const retlist = call_user_expand_func((user_expand_func_T)call_func_retlist, xp, num_file,
-                                                file);
-  if (retlist == NULL) {
-    return FAIL;
-  }
-
-  garray_T ga;
-  ga_init(&ga, (int)sizeof(char *), 3);
-  // Loop over the items in the list.
-  TV_LIST_ITER_CONST(retlist, li, {
-    if (TV_LIST_ITEM_TV(li)->v_type != VAR_STRING
-        || TV_LIST_ITEM_TV(li)->vval.v_string == NULL) {
-      continue;  // Skip non-string items and empty strings.
-    }
-
-    GA_APPEND(char *, &ga, xstrdup((const char *)TV_LIST_ITEM_TV(li)->vval.v_string));
-  });
-  tv_list_unref(retlist);
-
-  *file = ga.ga_data;
-  *num_file = ga.ga_len;
-  return OK;
-}
-
-static int ExpandUserLua(expand_T *xp, int *num_file, char ***file)
-{
-  typval_T rettv;
-  nlua_call_user_expand_func(xp, &rettv);
-  if (rettv.v_type != VAR_LIST) {
-    tv_clear(&rettv);
-    return FAIL;
-  }
-
-  list_T *const retlist = rettv.vval.v_list;
-
-  garray_T ga;
-  ga_init(&ga, (int)sizeof(char *), 3);
-  // Loop over the items in the list.
-  TV_LIST_ITER_CONST(retlist, li, {
-    if (TV_LIST_ITEM_TV(li)->v_type != VAR_STRING
-        || TV_LIST_ITEM_TV(li)->vval.v_string == NULL) {
-      continue;  // Skip non-string items and empty strings.
-    }
-
-    GA_APPEND(char *, &ga, xstrdup((const char *)TV_LIST_ITEM_TV(li)->vval.v_string));
-  });
-  tv_list_unref(retlist);
-
-  *file = ga.ga_data;
-  *num_file = ga.ga_len;
-  return OK;
+  return &ccline;
 }
 
-/// Expand `file` for all comma-separated directories in `path`.
-/// Adds matches to `ga`.
-void globpath(char *path, char_u *file, garray_T *ga, int expand_options)
+unsigned get_cmdline_last_prompt_id(void)
 {
-  expand_T xpc;
-  ExpandInit(&xpc);
-  xpc.xp_context = EXPAND_FILES;
-
-  char_u *buf = xmalloc(MAXPATHL);
-
-  // Loop over all entries in {path}.
-  while (*path != NUL) {
-    // Copy one item of the path to buf[] and concatenate the file name.
-    copy_option_part(&path, (char *)buf, MAXPATHL, ",");
-    if (STRLEN(buf) + STRLEN(file) + 2 < MAXPATHL) {
-      add_pathsep((char *)buf);
-      STRCAT(buf, file);  // NOLINT
-
-      char **p;
-      int num_p = 0;
-      (void)ExpandFromContext(&xpc, buf, &num_p, &p,
-                              WILD_SILENT | expand_options);
-      if (num_p > 0) {
-        ExpandEscape(&xpc, buf, num_p, p, WILD_SILENT | expand_options);
-
-        // Concatenate new results to previous ones.
-        ga_grow(ga, num_p);
-        // take over the pointers and put them in "ga"
-        for (int i = 0; i < num_p; i++) {
-          ((char_u **)ga->ga_data)[ga->ga_len] = (char_u *)p[i];
-          ga->ga_len++;
-        }
-        xfree(p);
-      }
-    }
-  }
-
-  xfree(buf);
+  return last_prompt_id;
 }
 
 /// Get pointer to the command line info to use. save_cmdline() may clear
 /// ccline and put the previous value in ccline.prev_ccline.
-static struct cmdline_info *get_ccline_ptr(void)
+static CmdlineInfo *get_ccline_ptr(void)
 {
   if ((State & MODE_CMDLINE) == 0) {
     return NULL;
@@ -5783,7 +4066,7 @@ char_u *get_cmdline_completion(void)
   if (cmdline_star > 0) {
     return NULL;
   }
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p != NULL && p->xpc != NULL) {
     set_expand_context(p->xpc);
@@ -5806,7 +4089,7 @@ char_u *get_cmdline_str(void)
   if (cmdline_star > 0) {
     return NULL;
   }
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p == NULL) {
     return NULL;
@@ -5822,7 +4105,7 @@ char_u *get_cmdline_str(void)
  */
 int get_cmdline_pos(void)
 {
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p == NULL) {
     return -1;
@@ -5833,7 +4116,7 @@ int get_cmdline_pos(void)
 /// Get the command line cursor screen position.
 int get_cmdline_screen_pos(void)
 {
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p == NULL) {
     return -1;
@@ -5848,7 +4131,7 @@ int get_cmdline_screen_pos(void)
  */
 int set_cmdline_pos(int pos)
 {
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p == NULL) {
     return 1;
@@ -5872,7 +4155,7 @@ int set_cmdline_pos(int pos)
  */
 int get_cmdline_type(void)
 {
-  struct cmdline_info *p = get_ccline_ptr();
+  CmdlineInfo *p = get_ccline_ptr();
 
   if (p == NULL) {
     return NUL;
diff --git a/src/nvim/ex_getln.h b/src/nvim/ex_getln.h
index 2f6929924d..5e3ad20a31 100644
--- a/src/nvim/ex_getln.h
+++ b/src/nvim/ex_getln.h
@@ -2,42 +2,77 @@
 #define NVIM_EX_GETLN_H
 
 #include "nvim/eval/typval.h"
-#include "nvim/ex_cmds.h"
-#include "nvim/regexp_defs.h"
-
-// Values for nextwild() and ExpandOne().  See ExpandOne() for meaning.
-#define WILD_FREE               1
-#define WILD_EXPAND_FREE        2
-#define WILD_EXPAND_KEEP        3
-#define WILD_NEXT               4
-#define WILD_PREV               5
-#define WILD_ALL                6
-#define WILD_LONGEST            7
-#define WILD_ALL_KEEP           8
-#define WILD_CANCEL             9
-#define WILD_APPLY              10
-
-#define WILD_LIST_NOTFOUND      0x01
-#define WILD_HOME_REPLACE       0x02
-#define WILD_USE_NL             0x04
-#define WILD_NO_BEEP            0x08
-#define WILD_ADD_SLASH          0x10
-#define WILD_KEEP_ALL           0x20
-#define WILD_SILENT             0x40
-#define WILD_ESCAPE             0x80
-#define WILD_ICASE              0x100
-#define WILD_ALLLINKS           0x200
-#define WILD_IGNORE_COMPLETESLASH   0x400
-#define WILD_NOERROR            0x800  // sets EW_NOERROR
-#define WILD_BUFLASTUSED        0x1000
-#define BUF_DIFF_FILTER         0x2000
-
-// flags used by vim_strsave_fnameescape()
-#define VSE_NONE        0
-#define VSE_SHELL       1       ///< escape for a shell command
-#define VSE_BUFFER      2       ///< escape for a ":buffer" command
-
-typedef char *(*CompleteListItemGetter)(expand_T *, int);
+#include "nvim/ex_cmds_defs.h"
+#include "nvim/types.h"
+
+/// Command-line colors: one chunk
+///
+/// Defines a region which has the same highlighting.
+typedef struct {
+  int start;  ///< Colored chunk start.
+  int end;  ///< Colored chunk end (exclusive, > start).
+  int attr;  ///< Highlight attr.
+} CmdlineColorChunk;
+
+/// Command-line colors
+///
+/// Holds data about all colors.
+typedef kvec_t(CmdlineColorChunk) CmdlineColors;
+
+/// Command-line coloring
+///
+/// Holds both what are the colors and what have been colored. Latter is used to
+/// suppress unnecessary calls to coloring callbacks.
+typedef struct {
+  unsigned prompt_id;  ///< ID of the prompt which was colored last.
+  char *cmdbuff;  ///< What exactly was colored last time or NULL.
+  CmdlineColors colors;  ///< Last colors.
+} ColoredCmdline;
+
+/// Keeps track how much state must be sent to external ui.
+typedef enum {
+  kCmdRedrawNone,
+  kCmdRedrawPos,
+  kCmdRedrawAll,
+} CmdRedraw;
+
+/// Variables shared between getcmdline(), redrawcmdline() and others.
+/// These need to be saved when using CTRL-R |, that's why they are in a
+/// structure.
+typedef struct cmdline_info CmdlineInfo;
+struct cmdline_info {
+  char_u *cmdbuff;              ///< pointer to command line buffer
+  int cmdbufflen;               ///< length of cmdbuff
+  int cmdlen;                   ///< number of chars in command line
+  int cmdpos;                   ///< current cursor position
+  int cmdspos;                  ///< cursor column on screen
+  int cmdfirstc;                ///< ':', '/', '?', '=', '>' or NUL
+  int cmdindent;                ///< number of spaces before cmdline
+  char_u *cmdprompt;            ///< message in front of cmdline
+  int cmdattr;                  ///< attributes for prompt
+  int overstrike;               ///< Typing mode on the command line.  Shared by
+                                ///< getcmdline() and put_on_cmdline().
+  expand_T *xpc;                ///< struct being used for expansion, xp_pattern
+                                ///< may point into cmdbuff
+  int xp_context;               ///< type of expansion
+  char_u *xp_arg;               ///< user-defined expansion arg
+  int input_fn;                 ///< when true Invoked for input() function
+  unsigned prompt_id;           ///< Prompt number, used to disable coloring on errors.
+  Callback highlight_callback;  ///< Callback used for coloring user input.
+  ColoredCmdline last_colors;   ///< Last cmdline colors
+  int level;                    ///< current cmdline level
+  CmdlineInfo *prev_ccline;     ///< pointer to saved cmdline state
+  char special_char;            ///< last putcmdline char (used for redraws)
+  bool special_shift;           ///< shift of last putcmdline char
+  CmdRedraw redraw_state;       ///< needed redraw for external cmdline
+};
+
+/// flags used by vim_strsave_fnameescape()
+enum {
+  VSE_NONE   = 0,
+  VSE_SHELL  = 1,  ///< escape for a shell command
+  VSE_BUFFER = 2,  ///< escape for a ":buffer" command
+};
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ex_getln.h.generated.h"
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index a3af7dc372..add650a430 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -20,6 +20,7 @@
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
 #include "nvim/event/loop.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
 #include "nvim/garray.h"
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 569f68e330..442f2e0b7b 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -8,9 +8,9 @@
 
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/ex_cmds.h"
 #include "nvim/ex_docmd.h"
-#include "nvim/ex_getln.h"
 #include "nvim/fileio.h"
 #include "nvim/garray.h"
 #include "nvim/globals.h"
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index c525a49bc3..938189f343 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -12,6 +12,7 @@
 #include "nvim/buffer.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cursor.h"
 #include "nvim/drawscreen.h"
 #include "nvim/edit.h"
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 5d97f90bb1..38c19ed456 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -22,6 +22,7 @@
 #include "nvim/eval/userfunc.h"
 #include "nvim/event/loop.h"
 #include "nvim/event/time.h"
+#include "nvim/ex_cmds.h"
 #include "nvim/ex_getln.h"
 #include "nvim/extmark.h"
 #include "nvim/func_attr.h"
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index 98ef4bd0f6..053c225b35 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -8,8 +8,8 @@
 
 #include "nvim/ascii.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/eval.h"
-#include "nvim/ex_getln.h"
 #include "nvim/macros.h"
 #include "nvim/map.h"
 #include "nvim/memory.h"
diff --git a/src/nvim/path.c b/src/nvim/path.c
index caea11debd..a581f4fa6d 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -8,9 +8,9 @@
 
 #include "nvim/ascii.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/eval.h"
 #include "nvim/ex_docmd.h"
-#include "nvim/ex_getln.h"
 #include "nvim/file_search.h"
 #include "nvim/fileio.h"
 #include "nvim/garray.h"
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index edcaa27e2b..914b21bb02 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -9,6 +9,7 @@
 #include "nvim/ascii.h"
 #include "nvim/autocmd.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/debugger.h"
 #include "nvim/eval.h"
 #include "nvim/eval/userfunc.h"
@@ -16,7 +17,6 @@
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_eval.h"
-#include "nvim/ex_getln.h"
 #include "nvim/lua/executor.h"
 #include "nvim/memline.h"
 #include "nvim/option.h"
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 4bc6e362eb..b471b93192 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -15,10 +15,10 @@
 
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cursor.h"
 #include "nvim/drawscreen.h"
 #include "nvim/eval.h"
-#include "nvim/ex_getln.h"
 #include "nvim/extmark.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 5866f11aab..65c56bf01b 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -13,6 +13,7 @@
 #include "nvim/ascii.h"
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
+#include "nvim/cmdexpand.h"
 #include "nvim/cursor.h"
 #include "nvim/drawscreen.h"
 #include "nvim/edit.h"