Merge pull request #5771 from brcolow/lambda

Lambda Support
2025-09-30 15:08:35 +00:00 · 2017-02-23 07:30:20 -05:00
parent 4e21311f9c d4dd447ded
commit 9752a333c3
24 changed files with 2129 additions and 580 deletions
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -221,11 +221,10 @@ Object nvim_call_function(String fname, Array args, Error *err)
  // Call the function
  typval_T rettv;
  int dummy;
-  int r = call_func((char_u *) fname.data, (int) fname.size,
-                    &rettv, (int) args.size, vim_args,
+  int r = call_func((char_u *)fname.data, (int)fname.size,
+                    &rettv, (int)args.size, vim_args, NULL,
                    curwin->w_cursor.lnum, curwin->w_cursor.lnum, &dummy,
-                    true,
-                    NULL, NULL);
+                    true, NULL, NULL);
  if (r == FAIL) {
    api_set_error(err, Exception, _("Error calling function."));
  }
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -31,8 +31,6 @@ typedef struct {
 #include "nvim/hashtab.h"
 // for dict_T
 #include "nvim/eval_defs.h"
-// for proftime_T
-#include "nvim/profile.h"
 // for String
 #include "nvim/api/private/defs.h"
 // for Map(K, V)
@@ -90,7 +88,6 @@ typedef struct {
 typedef struct window_S win_T;
 typedef struct wininfo_S wininfo_T;
 typedef struct frame_S frame_T;
-typedef int scid_T;                     /* script ID */

 // for struct memline (it needs memfile_T)
 #include "nvim/memline_defs.h"
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
--- a/src/nvim/eval.h
+++ b/src/nvim/eval.h
@@ -12,39 +12,6 @@

 // All user-defined functions are found in this hashtable.
 extern hashtab_T func_hashtab;
-
-// Structure to hold info for a user function.
-typedef struct ufunc ufunc_T;
-
-struct ufunc {
-  int          uf_varargs;       ///< variable nr of arguments
-  int          uf_flags;
-  int          uf_calls;         ///< nr of active calls
-  garray_T     uf_args;          ///< arguments
-  garray_T     uf_lines;         ///< function lines
-  int          uf_profiling;     ///< true when func is being profiled
-  // Profiling the function as a whole.
-  int          uf_tm_count;      ///< nr of calls
-  proftime_T   uf_tm_total;      ///< time spent in function + children
-  proftime_T   uf_tm_self;       ///< time spent in function itself
-  proftime_T   uf_tm_children;   ///< time spent in children this call
-  // Profiling the function per line.
-  int         *uf_tml_count;     ///< nr of times line was executed
-  proftime_T  *uf_tml_total;     ///< time spent in a line + children
-  proftime_T  *uf_tml_self;      ///< time spent in a line itself
-  proftime_T   uf_tml_start;     ///< start time for current line
-  proftime_T   uf_tml_children;  ///< time spent in children for this line
-  proftime_T   uf_tml_wait;      ///< start wait time for current line
-  int          uf_tml_idx;       ///< index of line being timed; -1 if none
-  int          uf_tml_execed;    ///< line being timed was executed
-  scid_T       uf_script_ID;     ///< ID of script where function was defined,
-                                 //   used for s: variables
-  int          uf_refcount;      ///< for numbered function: reference count
-  char_u       uf_name[1];       ///< name of function (actually longer); can
-                                 //   start with <SNR>123_ (<SNR> is K_SPECIAL
-                                 //   KS_EXTRA KE_SNR)
-};
-
 // From user function to hashitem and back.
 EXTERN ufunc_T dumuf;
 #define UF2HIKEY(fp) ((fp)->uf_name)
@@ -127,6 +94,7 @@ typedef enum {
    VV__NULL_LIST,  // List with NULL value. For test purposes only.
    VV__NULL_DICT,  // Dictionary with NULL value. For test purposes only.
    VV_VIM_DID_ENTER,
+    VV_TESTING,
    VV_TYPE_NUMBER,
    VV_TYPE_STRING,
    VV_TYPE_FUNC,
@@ -156,8 +124,8 @@ extern const list_T *eval_msgpack_type_lists[LAST_MSGPACK_TYPE + 1];

 #undef LAST_MSGPACK_TYPE

-/// Maximum number of function arguments
-#define MAX_FUNC_ARGS   20
+typedef int (*ArgvFunc)(int current_argcount, typval_T *argv,
+                        int called_func_argcount);

 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval.h.generated.h"
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -103,6 +103,7 @@ return {
    foldtext={},
    foldtextresult={args=1},
    foreground={},
+    funcref={args={1, 3}},
    ['function']={args={1, 3}},
    garbagecollect={args={0, 1}},
    get={args={2, 3}},
@@ -303,6 +304,7 @@ return {
    tanh={args=1, func="float_op_wrapper", data="&tanh"},
    tempname={},
    termopen={args={1, 2}},
+    test_garbagecollect_now={},
    timer_start={args={2,3}},
    timer_stop={args=1},
    tolower={args=1},
--- a/src/nvim/eval/typval_encode.c.h
+++ b/src/nvim/eval/typval_encode.c.h
@@ -344,7 +344,7 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
    case VAR_PARTIAL: {
      partial_T *const pt = tv->vval.v_partial;
      (void)pt;
-      TYPVAL_ENCODE_CONV_FUNC_START(tv, (pt == NULL ? NULL : pt->pt_name));
+      TYPVAL_ENCODE_CONV_FUNC_START(tv, (pt == NULL ? NULL : partial_name(pt)));
      _mp_push(*mpstack, ((MPConvStackVal) {
        .type = kMPConvPartial,
        .tv = tv,
--- a/src/nvim/eval_defs.h
+++ b/src/nvim/eval_defs.h
@@ -6,6 +6,9 @@

 #include "nvim/hashtab.h"
 #include "nvim/lib/queue.h"
+#include "nvim/garray.h"   // for garray_T
+#include "nvim/profile.h"  // for proftime_T
+#include "nvim/pos.h"      // for linenr_T

 typedef int varnumber_T;
 typedef double float_T;
@@ -104,15 +107,19 @@ struct listvar_S {
  list_T      *lv_used_prev;    /* previous list in used lists list */
 };

-/*
- * Structure to hold an item of a Dictionary.
- * Also used for a variable.
- * The key is copied into "di_key" to avoid an extra alloc/free for it.
- */
+// Static list with 10 items. Use init_static_list() to initialize.
+typedef struct {
+  list_T sl_list;  // must be first
+  listitem_T sl_items[10];
+} staticList10_T;
+
+// Structure to hold an item of a Dictionary.
+// Also used for a variable.
+// The key is copied into "di_key" to avoid an extra alloc/free for it.
 struct dictitem_S {
-  typval_T di_tv;               /* type and value of the variable */
-  char_u di_flags;              /* flags (only used for variable) */
-  char_u di_key[1];             /* key (actually longer!) */
+  typval_T di_tv;               ///< type and value of the variable
+  char_u di_flags;              ///< flags (only used for variable)
+  char_u di_key[1];             ///< key (actually longer!)
 };

 typedef struct dictitem_S dictitem_T;
@@ -147,9 +154,88 @@ struct dictvar_S {
  QUEUE watchers;         ///< Dictionary key watchers set by user code.
 };

+typedef int scid_T;                     // script ID
+typedef struct funccall_S funccall_T;
+
+// Structure to hold info for a user function.
+typedef struct ufunc ufunc_T;
+
+struct ufunc {
+  int          uf_varargs;       ///< variable nr of arguments
+  int          uf_flags;
+  int          uf_calls;         ///< nr of active calls
+  bool         uf_cleared;       ///< func_clear() was already called
+  garray_T     uf_args;          ///< arguments
+  garray_T     uf_lines;         ///< function lines
+  int          uf_profiling;     ///< true when func is being profiled
+  // Profiling the function as a whole.
+  int          uf_tm_count;      ///< nr of calls
+  proftime_T   uf_tm_total;      ///< time spent in function + children
+  proftime_T   uf_tm_self;       ///< time spent in function itself
+  proftime_T   uf_tm_children;   ///< time spent in children this call
+  // Profiling the function per line.
+  int         *uf_tml_count;     ///< nr of times line was executed
+  proftime_T  *uf_tml_total;     ///< time spent in a line + children
+  proftime_T  *uf_tml_self;      ///< time spent in a line itself
+  proftime_T   uf_tml_start;     ///< start time for current line
+  proftime_T   uf_tml_children;  ///< time spent in children for this line
+  proftime_T   uf_tml_wait;      ///< start wait time for current line
+  int          uf_tml_idx;       ///< index of line being timed; -1 if none
+  int          uf_tml_execed;    ///< line being timed was executed
+  scid_T       uf_script_ID;     ///< ID of script where function was defined,
+                                 //   used for s: variables
+  int          uf_refcount;      ///< reference count, see func_name_refcount()
+  funccall_T   *uf_scoped;       ///< l: local variables for closure
+  char_u       uf_name[1];       ///< name of function (actually longer); can
+                                 //   start with <SNR>123_ (<SNR> is K_SPECIAL
+                                 //   KS_EXTRA KE_SNR)
+};
+
+/// Maximum number of function arguments
+#define MAX_FUNC_ARGS   20
+#define VAR_SHORT_LEN   20      // short variable name length
+#define FIXVAR_CNT      12      // number of fixed variables
+
+// structure to hold info for a function that is currently being executed.
+struct funccall_S {
+  ufunc_T     *func;            ///< function being called
+  int linenr;                   ///< next line to be executed
+  int returned;                 ///< ":return" used
+  struct {                      ///< fixed variables for arguments
+    dictitem_T var;                     ///< variable (without room for name)
+    char_u room[VAR_SHORT_LEN];         ///< room for the name
+  } fixvar[FIXVAR_CNT];
+  dict_T l_vars;                ///< l: local function variables
+  dictitem_T l_vars_var;        ///< variable for l: scope
+  dict_T l_avars;               ///< a: argument variables
+  dictitem_T l_avars_var;       ///< variable for a: scope
+  list_T l_varlist;             ///< list for a:000
+  listitem_T l_listitems[MAX_FUNC_ARGS];        ///< listitems for a:000
+  typval_T    *rettv;           ///< return value
+  linenr_T breakpoint;          ///< next line with breakpoint or zero
+  int dbg_tick;                 ///< debug_tick when breakpoint was set
+  int level;                    ///< top nesting level of executed function
+  proftime_T prof_child;        ///< time spent in a child
+  funccall_T  *caller;          ///< calling function or NULL
+  int fc_refcount;              ///< number of user functions that reference
+                                // this funccal
+  int fc_copyID;                ///< for garbage collection
+  garray_T fc_funcs;            ///< list of ufunc_T* which keep a reference
+                                // to "func"
+};
+
+// structure used by trans_function_name()
+typedef struct {
+  dict_T      *fd_dict;         ///< Dictionary used.
+  char_u      *fd_newkey;       ///< New key in "dict" in allocated memory.
+  dictitem_T  *fd_di;           ///< Dictionary item used.
+} funcdict_T;
+
 struct partial_S {
  int pt_refcount;        ///< Reference count.
-  char_u *pt_name;        ///< Function name.
+  char_u *pt_name;        ///< Function name; when NULL use pt_func->name.
+  ufunc_T *pt_func;       ///< Function pointer; when NULL lookup function
+                          ///< with pt_name.
  bool pt_auto;           ///< when true the partial was created for using
                          ///< dict.member in handle_subscript().
  int pt_argc;            ///< Number of arguments.
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1327,8 +1327,9 @@ int using_script(void)
 void before_blocking(void)
 {
  updatescript(0);
-  if (may_garbage_collect)
-    garbage_collect();
+  if (may_garbage_collect) {
+    garbage_collect(false);
+  }
 }

 /*
@@ -1366,10 +1367,11 @@ int vgetc(void)
  char_u buf[MB_MAXBYTES + 1];
  int i;

-  /* Do garbage collection when garbagecollect() was called previously and
-   * we are now at the toplevel. */
-  if (may_garbage_collect && want_garbage_collect)
-    garbage_collect();
+  // Do garbage collection when garbagecollect() was called previously and
+  // we are now at the toplevel.
+  if (may_garbage_collect && want_garbage_collect) {
+    garbage_collect(false);
+  }

  /*
   * If a character was put back with vungetc, it was already processed.
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -1236,6 +1236,9 @@ EXTERN char *ignoredp;

 EXTERN bool in_free_unref_items INIT(= false);

+// Used for checking if local variables or arguments used in a lambda.
+EXTERN int *eval_lavars_used INIT(= NULL);
+
 // If a msgpack-rpc channel should be started over stdin/stdout
 EXTERN bool embedded_mode INIT(= false);

--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -624,8 +624,9 @@ void getout(int exitval)
  iconv_end();
 #endif
  cs_end();
-  if (garbage_collect_at_exit)
-    garbage_collect();
+  if (garbage_collect_at_exit) {
+    garbage_collect(false);
+  }

  mch_exit(exitval);
 }
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2460,11 +2460,11 @@ do_mouse (
          };
          typval_T rettv;
          int doesrange;
-          (void) call_func((char_u *) tab_page_click_defs[mouse_col].func,
-                           (int) strlen(tab_page_click_defs[mouse_col].func),
-                           &rettv, ARRAY_SIZE(argv), argv,
-                           curwin->w_cursor.lnum, curwin->w_cursor.lnum,
-                           &doesrange, true, NULL, NULL);
+          (void)call_func((char_u *)tab_page_click_defs[mouse_col].func,
+                          (int)strlen(tab_page_click_defs[mouse_col].func),
+                          &rettv, ARRAY_SIZE(argv), argv, NULL,
+                          curwin->w_cursor.lnum, curwin->w_cursor.lnum,
+                          &doesrange, true, NULL, NULL);
          clear_tv(&rettv);
          break;
        }
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -6442,32 +6442,72 @@ static linenr_T submatch_firstlnum;
 static linenr_T submatch_maxline;
 static int submatch_line_lbr;

-/*
- * vim_regsub() - perform substitutions after a vim_regexec() or
- * vim_regexec_multi() match.
- *
- * If "copy" is TRUE really copy into "dest".
- * If "copy" is FALSE nothing is copied, this is just to find out the length
- * of the result.
- *
- * If "backslash" is TRUE, a backslash will be removed later, need to double
- * them to keep them, and insert a backslash before a CR to avoid it being
- * replaced with a line break later.
- *
- * Note: The matched text must not change between the call of
- * vim_regexec()/vim_regexec_multi() and vim_regsub()!  It would make the back
- * references invalid!
- *
- * Returns the size of the replacement, including terminating NUL.
- */
-int vim_regsub(regmatch_T *rmp, char_u *source, char_u *dest, int copy, int magic, int backslash)
+/// Put the submatches in "argv[0]" which is a list passed into call_func() by
+/// vim_regsub_both().
+static int fill_submatch_list(int argc, typval_T *argv, int argcount)
+{
+  listitem_T *li;
+  int        i;
+  char_u     *s;
+
+  if (argcount == 0) {
+    // called function doesn't take an argument
+    return 0;
+  }
+
+  // Relies on sl_list to be the first item in staticList10_T.
+  init_static_list((staticList10_T *)(argv->vval.v_list));
+
+  // There are always 10 list items in staticList10_T.
+  li = argv->vval.v_list->lv_first;
+  for (i = 0; i < 10; i++) {
+    s = submatch_match->startp[i];
+    if (s == NULL || submatch_match->endp[i] == NULL) {
+      s = NULL;
+    } else {
+      s = vim_strnsave(s, (int)(submatch_match->endp[i] - s));
+    }
+    li->li_tv.v_type = VAR_STRING;
+    li->li_tv.vval.v_string = s;
+    li = li->li_next;
+  }
+  return 1;
+}
+
+static void clear_submatch_list(staticList10_T *sl)
+{
+  int i;
+
+  for (i = 0; i < 10; i++) {
+    xfree(sl->sl_items[i].li_tv.vval.v_string);
+  }
+}
+
+/// vim_regsub() - perform substitutions after a vim_regexec() or
+/// vim_regexec_multi() match.
+///
+/// If "copy" is TRUE really copy into "dest".
+/// If "copy" is FALSE nothing is copied, this is just to find out the length
+/// of the result.
+///
+/// If "backslash" is TRUE, a backslash will be removed later, need to double
+/// them to keep them, and insert a backslash before a CR to avoid it being
+/// replaced with a line break later.
+///
+/// Note: The matched text must not change between the call of
+/// vim_regexec()/vim_regexec_multi() and vim_regsub()!  It would make the back
+/// references invalid!
+///
+/// Returns the size of the replacement, including terminating NUL.
+int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest,
+               int copy, int magic, int backslash)
 {
  reg_match = rmp;
  reg_mmatch = NULL;
  reg_maxline = 0;
  reg_buf = curbuf;
-  reg_line_lbr = TRUE;
-  return vim_regsub_both(source, dest, copy, magic, backslash);
+  reg_line_lbr = true;
+  return vim_regsub_both(source, expr, dest, copy, magic, backslash);
 }

 int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int copy, int magic, int backslash)
@@ -6477,11 +6517,12 @@ int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *de
  reg_buf = curbuf;             /* always works on the current buffer! */
  reg_firstlnum = lnum;
  reg_maxline = curbuf->b_ml.ml_line_count - lnum;
-  reg_line_lbr = FALSE;
-  return vim_regsub_both(source, dest, copy, magic, backslash);
+  reg_line_lbr = false;
+  return vim_regsub_both(source, NULL, dest, copy, magic, backslash);
 }

-static int vim_regsub_both(char_u *source, char_u *dest, int copy, int magic, int backslash)
+static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
+                           int copy, int magic, int backslash)
 {
  char_u      *src;
  char_u      *dst;
@@ -6495,8 +6536,8 @@ static int vim_regsub_both(char_u *source, char_u *dest, int copy, int magic, in
  int len = 0;                  /* init for GCC */
  static char_u *eval_result = NULL;

-  /* Be paranoid... */
-  if (source == NULL || dest == NULL) {
+  // Be paranoid...
+  if ((source == NULL && expr == NULL) || dest == NULL) {
    EMSG(_(e_null));
    return 0;
  }
@@ -6505,16 +6546,13 @@ static int vim_regsub_both(char_u *source, char_u *dest, int copy, int magic, in
  src = source;
  dst = dest;

-  /*
-   * When the substitute part starts with "\=" evaluate it as an expression.
-   */
-  if (source[0] == '\\' && source[1] == '='
-      && !can_f_submatch            /* can't do this recursively */
-      ) {
-    /* To make sure that the length doesn't change between checking the
-     * length and copying the string, and to speed up things, the
-     * resulting string is saved from the call with "copy" == FALSE to the
-     * call with "copy" == TRUE. */
+  // When the substitute part starts with "\=" evaluate it as an expression.
+  if (expr != NULL || (source[0] == '\\' && source[1] == '='
+                       && !can_f_submatch)) {       // can't do this recursively
+    // To make sure that the length doesn't change between checking the
+    // length and copying the string, and to speed up things, the
+    // resulting string is saved from the call with "copy" == FALSE to the
+    // call with "copy" == TRUE.
    if (copy) {
      if (eval_result != NULL) {
        STRCPY(dest, eval_result);
@@ -6525,6 +6563,7 @@ static int vim_regsub_both(char_u *source, char_u *dest, int copy, int magic, in
    } else {
      win_T       *save_reg_win;
      int save_ireg_ic;
+      bool prev_can_f_submatch = can_f_submatch;

      xfree(eval_result);

@@ -6539,9 +6578,50 @@ static int vim_regsub_both(char_u *source, char_u *dest, int copy, int magic, in
      submatch_line_lbr = reg_line_lbr;
      save_reg_win = reg_win;
      save_ireg_ic = ireg_ic;
-      can_f_submatch = TRUE;
+      can_f_submatch = true;
+
+      if (expr != NULL) {
+        typval_T argv[2];
+        int dummy;
+        char_u buf[NUMBUFLEN];
+        typval_T rettv;
+        staticList10_T matchList;
+
+        rettv.v_type = VAR_STRING;
+        rettv.vval.v_string = NULL;
+        if (prev_can_f_submatch) {
+          // can't do this recursively
+        } else {
+          argv[0].v_type = VAR_LIST;
+          argv[0].vval.v_list = &matchList.sl_list;
+          matchList.sl_list.lv_len = 0;
+          if (expr->v_type == VAR_FUNC) {
+            s = expr->vval.v_string;
+            call_func(s, (int)STRLEN(s), &rettv, 1, argv,
+                      fill_submatch_list, 0L, 0L, &dummy,
+                      true, NULL, NULL);
+          } else if (expr->v_type == VAR_PARTIAL) {
+            partial_T *partial = expr->vval.v_partial;
+
+            s = partial_name(partial);
+            call_func(s, (int)STRLEN(s), &rettv, 1, argv,
+                      fill_submatch_list, 0L, 0L, &dummy,
+                      true, partial, NULL);
+          }
+          if (matchList.sl_list.lv_len > 0) {
+            // fill_submatch_list() was called.
+            clear_submatch_list(&matchList);
+          }
+        }
+        eval_result = get_tv_string_buf_chk(&rettv, buf);
+        if (eval_result != NULL) {
+          eval_result = vim_strsave(eval_result);
+        }
+        clear_tv(&rettv);
+      } else {
+        eval_result = eval_to_string(source + 2, NULL, true);
+      }

-      eval_result = eval_to_string(source + 2, NULL, TRUE);
      if (eval_result != NULL) {
        int had_backslash = FALSE;

--- a/src/nvim/testdir/Makefile
+++ b/src/nvim/testdir/Makefile
@@ -34,12 +34,14 @@ NEW_TESTS ?= \
 	    test_cscope.res \
 	    test_digraph.res \
 	    test_diffmode.res \
+	    test_filter_map.res \
 	    test_gn.res \
 	    test_hardcopy.res \
 	    test_help_tagjump.res \
 	    test_history.res \
 	    test_increment.res \
 	    test_increment_dbcs.res \
+		test_lambda.res \
 	    test_langmap.res \
 	    test_match.res \
 	    test_matchadd_conceal.res \
--- a/src/nvim/testdir/runtest.vim
+++ b/src/nvim/testdir/runtest.vim
@@ -62,6 +62,12 @@ lang mess C
 " Always use forward slashes.
 set shellslash

+" Make sure $HOME does not get read or written.
+let $HOME = '/does/not/exist'
+
+" Prepare for calling garbagecollect_for_testing().
+let v:testing = 1
+
 " Align with vim defaults.
 set directory^=.
 set nohidden
--- a/src/nvim/testdir/test_alot.vim
+++ b/src/nvim/testdir/test_alot.vim
@@ -9,8 +9,10 @@ source test_ex_undo.vim
 source test_expr.vim
 source test_expr_utf8.vim
 source test_feedkeys.vim
+source test_filter_map.vim
 source test_goto.vim
 source test_jumps.vim
+source test_lambda.vim
 source test_match.vim
 source test_matchadd_conceal_utf8.vim
 source test_menu.vim
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -85,6 +85,11 @@ func Test_getcompletion()
  let l = getcompletion('paint', 'function')
  call assert_equal([], l)

+  let Flambda = {-> 'hello'}
+  let l = getcompletion('', 'function')
+  let l = filter(l, {i, v -> v =~ 'lambda'})
+  call assert_equal(0, len(l))
+
  let l = getcompletion('run', 'file')
  call assert_true(index(l, 'runtest.vim') >= 0)
  let l = getcompletion('walk', 'file')
--- a/src/nvim/testdir/test_expr.vim
+++ b/src/nvim/testdir/test_expr.vim
@@ -106,3 +106,68 @@ func Test_setmatches()
  call setmatches(set)
  call assert_equal(exp, getmatches())
 endfunc
+
+func Test_substitute_expr()
+  let g:val = 'XXX'
+  call assert_equal('XXX', substitute('yyy', 'y*', '\=g:val', ''))
+  call assert_equal('XXX', substitute('yyy', 'y*', {-> g:val}, ''))
+  call assert_equal("-\u1b \uf2-", substitute("-%1b %f2-", '%\(\x\x\)',
+			   \ '\=nr2char("0x" . submatch(1))', 'g'))
+  call assert_equal("-\u1b \uf2-", substitute("-%1b %f2-", '%\(\x\x\)',
+			   \ {-> nr2char("0x" . submatch(1))}, 'g'))
+
+  call assert_equal('231', substitute('123', '\(.\)\(.\)\(.\)',
+	\ {-> submatch(2) . submatch(3) . submatch(1)}, ''))
+
+  func Recurse()
+    return substitute('yyy', 'y*', {-> g:val}, '')
+  endfunc
+  call assert_equal('--', substitute('xxx', 'x*', {-> '-' . Recurse() . '-'}, ''))
+endfunc
+
+func Test_invalid_submatch()
+  " This was causing invalid memory access in Vim-7.4.2232 and older
+  call assert_fails("call substitute('x', '.', {-> submatch(10)}, '')", 'E935:')
+endfunc
+
+func Test_substitute_expr_arg()
+  call assert_equal('123456789-123456789=', substitute('123456789',
+	\ '\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)',
+	\ {m -> m[0] . '-' . m[1] . m[2] . m[3] . m[4] . m[5] . m[6] . m[7] . m[8] . m[9] . '='}, ''))
+
+  call assert_equal('123456-123456=789', substitute('123456789',
+	\ '\(.\)\(.\)\(.\)\(a*\)\(n*\)\(.\)\(.\)\(.\)\(x*\)',
+	\ {m -> m[0] . '-' . m[1] . m[2] . m[3] . m[4] . m[5] . m[6] . m[7] . m[8] . m[9] . '='}, ''))
+
+  call assert_equal('123456789-123456789x=', substitute('123456789',
+	\ '\(.\)\(.\)\(.*\)',
+	\ {m -> m[0] . '-' . m[1] . m[2] . m[3] . 'x' . m[4] . m[5] . m[6] . m[7] . m[8] . m[9] . '='}, ''))
+
+  call assert_fails("call substitute('xxx', '.', {m -> string(add(m, 'x'))}, '')", 'E742:')
+  call assert_fails("call substitute('xxx', '.', {m -> string(insert(m, 'x'))}, '')", 'E742:')
+  call assert_fails("call substitute('xxx', '.', {m -> string(extend(m, ['x']))}, '')", 'E742:')
+  call assert_fails("call substitute('xxx', '.', {m -> string(remove(m, 1))}, '')", 'E742:')
+endfunc
+
+func Test_function_with_funcref()
+  let s:f = function('type')
+  let s:fref = function(s:f)
+  call assert_equal(v:t_string, s:fref('x'))
+  call assert_fails("call function('s:f')", 'E700:')
+endfunc
+
+func Test_funcref()
+  func! One()
+    return 1
+  endfunc
+  let OneByName = function('One')
+  let OneByRef = funcref('One')
+  func! One()
+    return 2
+  endfunc
+  call assert_equal(2, OneByName())
+  call assert_equal(1, OneByRef())
+  let OneByRef = funcref('One')
+  call assert_equal(2, OneByRef())
+  call assert_fails('echo funcref("{")', 'E475:')
+endfunc
--- a/src/nvim/testdir/test_filter_map.vim
+++ b/src/nvim/testdir/test_filter_map.vim
@@ -0,0 +1,81 @@
+" Test filter() and map()
+
+" list with expression string
+func Test_filter_map_list_expr_string()
+  " filter()
+  call assert_equal([2, 3, 4], filter([1, 2, 3, 4], 'v:val > 1'))
+  call assert_equal([3, 4], filter([1, 2, 3, 4], 'v:key > 1'))
+  call assert_equal([], filter([1, 2, 3, 4], 0))
+
+  " map()
+  call assert_equal([2, 4, 6, 8], map([1, 2, 3, 4], 'v:val * 2'))
+  call assert_equal([0, 2, 4, 6], map([1, 2, 3, 4], 'v:key * 2'))
+  call assert_equal([9, 9, 9, 9], map([1, 2, 3, 4], 9))
+endfunc
+
+" dict with expression string
+func Test_filter_map_dict_expr_string()
+  let dict = {"foo": 1, "bar": 2, "baz": 3}
+
+  " filter()
+  call assert_equal({"bar": 2, "baz": 3}, filter(copy(dict), 'v:val > 1'))
+  call assert_equal({"foo": 1, "baz": 3}, filter(copy(dict), 'v:key > "bar"'))
+  call assert_equal({}, filter(copy(dict), 0))
+
+  " map()
+  call assert_equal({"foo": 2, "bar": 4, "baz": 6}, map(copy(dict), 'v:val * 2'))
+  call assert_equal({"foo": "f", "bar": "b", "baz": "b"}, map(copy(dict), 'v:key[0]'))
+  call assert_equal({"foo": 9, "bar": 9, "baz": 9}, map(copy(dict), 9))
+endfunc
+
+" list with funcref
+func Test_filter_map_list_expr_funcref()
+  " filter()
+  func! s:filter1(index, val) abort
+    return a:val > 1
+  endfunc
+  call assert_equal([2, 3, 4], filter([1, 2, 3, 4], function('s:filter1')))
+
+  func! s:filter2(index, val) abort
+    return a:index > 1
+  endfunc
+  call assert_equal([3, 4], filter([1, 2, 3, 4], function('s:filter2')))
+
+  " map()
+  func! s:filter3(index, val) abort
+    return a:val * 2
+  endfunc
+  call assert_equal([2, 4, 6, 8], map([1, 2, 3, 4], function('s:filter3')))
+
+  func! s:filter4(index, val) abort
+    return a:index * 2
+  endfunc
+  call assert_equal([0, 2, 4, 6], map([1, 2, 3, 4], function('s:filter4')))
+endfunc
+
+" dict with funcref
+func Test_filter_map_dict_expr_funcref()
+  let dict = {"foo": 1, "bar": 2, "baz": 3}
+
+  " filter()
+  func! s:filter1(key, val) abort
+    return a:val > 1
+  endfunc
+  call assert_equal({"bar": 2, "baz": 3}, filter(copy(dict), function('s:filter1')))
+
+  func! s:filter2(key, val) abort
+    return a:key > "bar"
+  endfunc
+  call assert_equal({"foo": 1, "baz": 3}, filter(copy(dict), function('s:filter2')))
+
+  " map()
+  func! s:filter3(key, val) abort
+    return a:val * 2
+  endfunc
+  call assert_equal({"foo": 2, "bar": 4, "baz": 6}, map(copy(dict), function('s:filter3')))
+
+  func! s:filter4(key, val) abort
+    return a:key[0]
+  endfunc
+  call assert_equal({"foo": "f", "bar": "b", "baz": "b"}, map(copy(dict), function('s:filter4')))
+endfunc
--- a/src/nvim/testdir/test_lambda.vim
+++ b/src/nvim/testdir/test_lambda.vim
@@ -0,0 +1,287 @@
+" Test for lambda and closure
+
+function! Test_lambda_feature()
+  call assert_equal(1, has('lambda'))
+endfunction
+
+function! Test_lambda_with_filter()
+  let s:x = 2
+  call assert_equal([2, 3], filter([1, 2, 3], {i, v -> v >= s:x}))
+endfunction
+
+function! Test_lambda_with_map()
+  let s:x = 1
+  call assert_equal([2, 3, 4], map([1, 2, 3], {i, v -> v + s:x}))
+endfunction
+
+function! Test_lambda_with_sort()
+  call assert_equal([1, 2, 3, 4, 7], sort([3,7,2,1,4], {a, b -> a - b}))
+endfunction
+
+function! Test_lambda_with_timer()
+  if !has('timers')
+    return
+  endif
+
+  let s:n = 0
+  let s:timer_id = 0
+  function! s:Foo()
+    "let n = 0
+    let s:timer_id = timer_start(50, {-> execute("let s:n += 1 | echo s:n", "")}, {"repeat": -1})
+  endfunction
+
+  call s:Foo()
+  sleep 200ms
+  " do not collect lambda
+  call garbagecollect()
+  let m = s:n
+  sleep 200ms
+  call timer_stop(s:timer_id)
+  call assert_true(m > 1)
+  call assert_true(s:n > m + 1)
+  call assert_true(s:n < 9)
+endfunction
+
+function! Test_lambda_with_partial()
+  let l:Cb = function({... -> ['zero', a:1, a:2, a:3]}, ['one', 'two'])
+  call assert_equal(['zero', 'one', 'two', 'three'], l:Cb('three'))
+endfunction
+
+function Test_lambda_fails()
+  call assert_equal(3, {a, b -> a + b}(1, 2))
+  call assert_fails('echo {a, a -> a + a}(1, 2)', 'E15:')
+  call assert_fails('echo {a, b -> a + b)}(1, 2)', 'E15:')
+endfunc
+
+func Test_not_lambda()
+  let x = {'>' : 'foo'}
+  call assert_equal('foo', x['>'])
+endfunc
+
+function! Test_lambda_capture_by_reference()
+  let v = 1
+  let l:F = {x -> x + v}
+  let v = 2
+  call assert_equal(12, l:F(10))
+endfunction
+
+function! Test_lambda_side_effect()
+  function! s:update_and_return(arr)
+    let a:arr[1] = 5
+    return a:arr
+  endfunction
+
+  function! s:foo(arr)
+    return {-> s:update_and_return(a:arr)}
+  endfunction
+
+  let arr = [3,2,1]
+  call assert_equal([3, 5, 1], s:foo(arr)())
+endfunction
+
+function! Test_lambda_refer_local_variable_from_other_scope()
+  function! s:foo(X)
+    return a:X() " refer l:x in s:bar()
+  endfunction
+
+  function! s:bar()
+    let x = 123
+    return s:foo({-> x})
+  endfunction
+
+  call assert_equal(123, s:bar())
+endfunction
+
+function! Test_lambda_do_not_share_local_variable()
+  function! s:define_funcs()
+    let l:One = {-> split(execute("let a = 'abc' | echo a"))[0]}
+    let l:Two = {-> exists("a") ? a : "no"}
+    return [l:One, l:Two]
+  endfunction
+
+  let l:F = s:define_funcs()
+
+  call assert_equal('no', l:F[1]())
+  call assert_equal('abc', l:F[0]())
+  call assert_equal('no', l:F[1]())
+endfunction
+
+function! Test_lambda_closure_counter()
+  function! s:foo()
+    let x = 0
+    return {-> [execute("let x += 1"), x][-1]}
+  endfunction
+
+  let l:F = s:foo()
+  call garbagecollect()
+  call assert_equal(1, l:F())
+  call assert_equal(2, l:F())
+  call assert_equal(3, l:F())
+  call assert_equal(4, l:F())
+endfunction
+
+function! Test_lambda_with_a_var()
+  function! s:foo()
+    let x = 2
+    return {... -> a:000 + [x]}
+  endfunction
+  function! s:bar()
+    return s:foo()(1)
+  endfunction
+
+  call assert_equal([1, 2], s:bar())
+endfunction
+
+function! Test_lambda_call_lambda_from_lambda()
+  function! s:foo(x)
+    let l:F1 = {-> {-> a:x}}
+    return {-> l:F1()}
+  endfunction
+
+  let l:F = s:foo(1)
+  call assert_equal(1, l:F()())
+endfunction
+
+function! Test_lambda_delfunc()
+  function! s:gen()
+    let pl = l:
+    let l:Foo = {-> get(pl, "Foo", get(pl, "Bar", {-> 0}))}
+    let l:Bar = l:Foo
+    delfunction l:Foo
+    return l:Bar
+  endfunction
+
+  let l:F = s:gen()
+  call assert_fails(':call l:F()', 'E933:')
+endfunction
+
+function! Test_lambda_scope()
+  function! s:NewCounter()
+    let c = 0
+    return {-> [execute('let c += 1'), c][-1]}
+  endfunction
+
+  function! s:NewCounter2()
+    return {-> [execute('let c += 100'), c][-1]}
+  endfunction
+
+  let l:C = s:NewCounter()
+  let l:D = s:NewCounter2()
+
+  call assert_equal(1, l:C())
+  call assert_fails(':call l:D()', 'E15:') " E121: then E15:
+  call assert_equal(2, l:C())
+endfunction
+
+function! Test_lambda_share_scope()
+  function! s:New()
+    let c = 0
+    let l:Inc0 = {-> [execute('let c += 1'), c][-1]}
+    let l:Dec0 = {-> [execute('let c -= 1'), c][-1]}
+    return [l:Inc0, l:Dec0]
+  endfunction
+
+  let [l:Inc, l:Dec] = s:New()
+
+  call assert_equal(1, l:Inc())
+  call assert_equal(2, l:Inc())
+  call assert_equal(1, l:Dec())
+endfunction
+
+function! Test_lambda_circular_reference()
+  function! s:Foo()
+    let d = {}
+    let d.f = {-> d}
+    return d.f
+  endfunction
+
+  call s:Foo()
+  call garbagecollect()
+  let i = 0 | while i < 10000 | call s:Foo() | let i+= 1 | endwhile
+  call garbagecollect()
+endfunction
+
+function! Test_lambda_combination()
+  call assert_equal(2, {x -> {x -> x}}(1)(2))
+  call assert_equal(10, {y -> {x -> x(y)(10)}({y -> y})}({z -> z}))
+  call assert_equal(5.0, {x -> {y -> x / y}}(10)(2.0))
+  call assert_equal(6, {x -> {y -> {z -> x + y + z}}}(1)(2)(3))
+
+  call assert_equal(6, {x -> {f -> f(x)}}(3)({x -> x * 2}))
+  call assert_equal(6, {f -> {x -> f(x)}}({x -> x * 2})(3))
+
+  " Z combinator
+  let Z = {f -> {x -> f({y -> x(x)(y)})}({x -> f({y -> x(x)(y)})})}
+  let Fact = {f -> {x -> x == 0 ? 1 : x * f(x - 1)}}
+  call assert_equal(120, Z(Fact)(5))
+endfunction
+
+function! Test_closure_counter()
+  function! s:foo()
+    let x = 0
+    function! s:bar() closure
+      let x += 1
+      return x
+    endfunction
+    return function('s:bar')
+  endfunction
+
+  let l:F = s:foo()
+  call garbagecollect()
+  call assert_equal(1, l:F())
+  call assert_equal(2, l:F())
+  call assert_equal(3, l:F())
+  call assert_equal(4, l:F())
+endfunction
+
+function! Test_closure_unlet()
+  function! s:foo()
+    let x = 1
+    function! s:bar() closure
+      unlet x
+    endfunction
+    call s:bar()
+    return l:
+  endfunction
+
+  call assert_false(has_key(s:foo(), 'x'))
+  call garbagecollect()
+endfunction
+
+function! LambdaFoo()
+  let x = 0
+  function! LambdaBar() closure
+    let x += 1
+    return x
+  endfunction
+  return function('LambdaBar')
+endfunction
+
+func Test_closure_refcount()
+  let g:Count = LambdaFoo()
+  call test_garbagecollect_now()
+  call assert_equal(1, g:Count())
+  let g:Count2 = LambdaFoo()
+  call test_garbagecollect_now()
+  call assert_equal(1, g:Count2())
+  call assert_equal(2, g:Count())
+  call assert_equal(3, g:Count2())
+
+  delfunc LambdaFoo
+  delfunc LambdaBar
+endfunc
+
+" This test is causing a use-after-free on shutdown.
+func Test_named_function_closure()
+  func! Afoo()
+    let x = 14
+    func! s:Abar() closure
+      return x
+    endfunc
+    call assert_equal(14, s:Abar())
+  endfunc
+  call Afoo()
+  call assert_equal(14, s:Abar())
+  call garbagecollect()
+  call assert_equal(14, s:Abar())
+endfunc
--- a/src/nvim/testdir/test_partial.vim
+++ b/src/nvim/testdir/test_partial.vim
@@ -14,6 +14,14 @@ func MySort(up, one, two)
  return a:one < a:two ? 1 : -1
 endfunc

+func MyMap(sub, index, val)
+  return a:val - a:sub
+endfunc
+
+func MyFilter(threshold, index, val)
+  return a:val > a:threshold
+endfunc
+
 func Test_partial_args()
  let Cb = function('MyFunc', ["foo", "bar"])

@@ -36,6 +44,16 @@ func Test_partial_args()
  call assert_equal([1, 2, 3], sort([3, 1, 2], Sort))
  let Sort = function('MySort', [0])
  call assert_equal([3, 2, 1], sort([3, 1, 2], Sort))
+
+  let Map = function('MyMap', [2])
+  call assert_equal([-1, 0, 1], map([1, 2, 3], Map))
+  let Map = function('MyMap', [3])
+  call assert_equal([-2, -1, 0], map([1, 2, 3], Map))
+
+  let Filter = function('MyFilter', [1])
+  call assert_equal([2, 3], filter([1, 2, 3], Filter))
+  let Filter = function('MyFilter', [2])
+  call assert_equal([3], filter([1, 2, 3], Filter))
 endfunc

 func MyDictFunc(arg1, arg2) dict
@@ -59,6 +77,9 @@ func Test_partial_dict()
  call assert_equal("hello/xxx/yyy", Cb("xxx", "yyy"))
  call assert_fails('Cb("fff")', 'E492:')

+  let Cb = function('MyDictFunc', dict)
+  call assert_equal({"foo": "hello/foo/1", "bar": "hello/bar/2"}, map({"foo": 1, "bar": 2}, Cb))
+
  let dict = {"tr": function('tr', ['hello', 'h', 'H'])}
  call assert_equal("Hello", dict.tr())
 endfunc
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -205,9 +205,9 @@ static int included_patches[] = {
  // 2238 NA
  2237,
  // 2236,
-  // 2235,
+  2235,
  // 2234 NA
-  // 2233,
+  2233,
  // 2232 NA
  // 2231,
  // 2230,
@@ -243,7 +243,7 @@ static int included_patches[] = {
  // 2200,
  // 2199 NA
  // 2198 NA
-  // 2197,
+  2197,
  // 2196,
  // 2195 NA
  2194,
@@ -297,16 +297,16 @@ static int included_patches[] = {
  2146,
  // 2145 NA
  // 2144,
-  // 2143,
-  // 2142,
-  // 2141,
+  2143,
+  2142,
+  2141,
  // 2140 NA
-  // 2139,
+  2139,
  // 2138 NA
-  // 2137,
-  // 2136,
+  2137,
+  2136,
  // 2135,
-  // 2134,
+  2134,
  // 2133 NA
  // 2132 NA
  // 2131 NA
@@ -319,9 +319,9 @@ static int included_patches[] = {
  2124,
  2123,
  // 2122 NA
-  // 2121,
-  // 2120,
-  // 2119,
+  2121,
+  2120,
+  2119,
  // 2118 NA
  2117,
  // 2116 NA
@@ -344,13 +344,13 @@ static int included_patches[] = {
  2099,
  // 2098,
  // 2097,
-  // 2096,
+  2096,
  // 2095,
  // 2094 NA
  // 2093 NA
  // 2092 NA
  // 2091 NA
-  // 2090,
+  2090,
  // 2089 NA
  2088,
  2087,
@@ -364,11 +364,11 @@ static int included_patches[] = {
  // 2079 NA
  // 2078 NA
  2077,
-  // 2076,
+  2076,
  2075,
  2074,
  // 2073 NA
-  // 2072,
+  2072,
  2071,
  // 2070 NA
  // 2069,
@@ -396,7 +396,7 @@ static int included_patches[] = {
  // 2047,
  // 2046,
  // 2045 NA
-  // 2044,
+  2044,
  2043,
  // 2042 NA
  // 2041 NA
@@ -438,7 +438,7 @@ static int included_patches[] = {
  2005,
  // 2004 NA
  // 2003 NA
-  // 2002,
+  2002,
  // 2001 NA
  2000,
  1999,
@@ -451,7 +451,7 @@ static int included_patches[] = {
  // 1992,
  // 1991,
  1990,
-  // 1989,
+  1989,
  // 1988 NA
  // 1987 NA
  // 1986,
@@ -714,7 +714,7 @@ static int included_patches[] = {
  1730,
  // 1729 NA
  1728,
-  // 1727 NA
+  1727,
  // 1726 NA
  // 1725 NA
  // 1724 NA