Merge remote-tracking branch 'vim/master'

Author: splhack

runtime/doc/eval.txt

@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 7.4.  Last change: 2016 Jul 29
+*eval.txt*	For Vim version 7.4.  Last change: 2016 Jul 31
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -1240,7 +1240,9 @@ function returns: >
 	:let Bar = Foo(4)
 	:echo Bar(6)
 <	5
-See also |:func-closure|.
+
+See also |:func-closure|.  Lambda and closure support can be checked with: >
+	if has('lambda')
 
 Examples for using a lambda expression with |sort()|, |map()| and |filter()|: >
 	:echo map([1, 2, 3], {idx, val -> val + 1})
@@ -2071,8 +2073,10 @@ foldlevel({lnum})		Number	fold level at {lnum}
 foldtext()			String	line displayed for closed fold
 foldtextresult({lnum})		String	text for closed fold at {lnum}
 foreground()			Number	bring the Vim window to the foreground
-function({name} [, {arglist}] [, {dict}])
+funcref({name} [, {arglist}] [, {dict}])
 				Funcref	reference to function {name}
+function({name} [, {arglist}] [, {dict}])
+				Funcref	named reference to function {name}
 garbagecollect([{atexit}])	none	free memory, breaking cyclic references
 get({list}, {idx} [, {def}])	any	get item {idx} from {list} or {def}
 get({dict}, {key} [, {def}])	any	get item {key} from {dict} or {def}
@@ -3850,19 +3854,32 @@ foreground()	Move the Vim window to the foreground.	Useful when sent from
 		{only in the Win32, Athena, Motif and GTK GUI versions and the
 		Win32 console version}
 
+						*funcref()*
+funcref({name} [, {arglist}] [, {dict}])
+		Just like |function()|, but the returned Funcref will lookup
+		the function by reference, not by name.  This matters when the
+		function {name} is redefined later.
+
+		Unlike |function()|, {name} must be an existing user function.
+		Also for autoloaded functions. {name} cannot be a builtin
+		function.
 
 					*function()* *E700* *E922* *E923*
 function({name} [, {arglist}] [, {dict}])
 		Return a |Funcref| variable that refers to function {name}.
 		{name} can be the name of a user defined function or an
 		internal function.
 
-		{name} can also be a Funcref, also a partial.  When it is a
+		{name} can also be a Funcref or a partial.  When it is a
 		partial the dict stored in it will be used and the {dict}
 		argument is not allowed. E.g.: >
 			let FuncWithArg = function(dict.Func, [arg])
 			let Broken = function(dict.Func, [arg], dict)
 <
+		When using the Funcref the function will be found by {name},
+		also when it was redefined later.  Use |funcref()| to keep the
+		same function.
+
 		When {arglist} or {dict} is present this creates a partial.
 		That means the argument list and/or the dictionary is stored in
 		the Funcref and will be used when the Funcref is called.
@@ -6191,6 +6208,7 @@ screenrow()							*screenrow()*
 		The result is a Number, which is the current screen row of the
 		cursor.  The top line has number one.
 		This function is mainly used for testing.
+		Alternatively you can use |winline()|.
 
 		Note: Same restrictions as with |screencol()|.
 
@@ -8041,6 +8059,7 @@ insert_expand		Compiled with support for CTRL-X expansion commands in
 			Insert mode.
 jumplist		Compiled with |jumplist| support.
 keymap			Compiled with 'keymap' support.
+lambda			Compiled with |lambda| support.
 langmap			Compiled with 'langmap' support.
 libcall			Compiled with |libcall()| support.
 linebreak		Compiled with 'linebreak', 'breakat', 'showbreak' and
@@ -8298,7 +8317,7 @@ See |:verbose-cmd| for more information.
 :endf[unction]		The end of a function definition.  Must be on a line
 			by its own, without other commands.
 
-					*:delf* *:delfunction* *E130* *E131*
+				*:delf* *:delfunction* *E130* *E131* *E933*
 :delf[unction] {name}	Delete function {name}.
 			{name} can also be a |Dictionary| entry that is a
 			|Funcref|: >

runtime/menu.vim

@@ -2,7 +2,7 @@
 " You can also use this as a start for your own set of menus.
 "
 " Maintainer:	Bram Moolenaar <[email protected]>
-" Last Change:	2014 May 22
+" Last Change:	2016 Jul 27
 
 " Note that ":an" (short for ":anoremenu") is often used to make a menu work
 " in all modes and avoid side effects from mappings defined by the user.

src/INSTALLpc.txt

@@ -49,7 +49,7 @@ Building with Visual Studio (VS 98, VS .NET, VS .NET 2003, VS 2005, VS 2008,
 VS2010, VS2012, VS2013 and VS2015) is straightforward. (These instructions
 should also work for VS 4 and VS 5.)
 
-Using VS C++ 2008 Express is recommended, the binaries build with that run on
+Using VS C++ 2008 Express is recommended, the binaries built with that run on
 nearly all platforms.  Binaries from later versions may not run on Windows 95
 or XP.
 

src/channel.c

@@ -1145,15 +1145,18 @@ set_callback(
     if (callback != NULL && *callback != NUL)
     {
 	if (partial != NULL)
-	    *cbp = partial->pt_name;
+	    *cbp = partial_name(partial);
 	else
+	{
 	    *cbp = vim_strsave(callback);
+	    func_ref(*cbp);
+	}
     }
     else
 	*cbp = NULL;
     *pp = partial;
-    if (*pp != NULL)
-	++(*pp)->pt_refcount;
+    if (partial != NULL)
+	++partial->pt_refcount;
 }
 
 /*
@@ -1300,7 +1303,10 @@ channel_set_req_callback(
 	    item->cq_callback = callback;
 	}
 	else
+	{
 	    item->cq_callback = vim_strsave(callback);
+	    func_ref(item->cq_callback);
+	}
 	item->cq_seq_nr = id;
 	item->cq_prev = head->cq_prev;
 	head->cq_prev = item;
@@ -3948,14 +3954,24 @@ free_job_options(jobopt_T *opt)
 {
     if (opt->jo_partial != NULL)
 	partial_unref(opt->jo_partial);
+    else if (opt->jo_callback != NULL)
+	func_unref(opt->jo_callback);
     if (opt->jo_out_partial != NULL)
 	partial_unref(opt->jo_out_partial);
+    else if (opt->jo_out_cb != NULL)
+	func_unref(opt->jo_out_cb);
     if (opt->jo_err_partial != NULL)
 	partial_unref(opt->jo_err_partial);
+    else if (opt->jo_err_cb != NULL)
+	func_unref(opt->jo_err_cb);
     if (opt->jo_close_partial != NULL)
 	partial_unref(opt->jo_close_partial);
+    else if (opt->jo_close_cb != NULL)
+	func_unref(opt->jo_close_cb);
     if (opt->jo_exit_partial != NULL)
 	partial_unref(opt->jo_exit_partial);
+    else if (opt->jo_exit_cb != NULL)
+	func_unref(opt->jo_exit_cb);
 }
 
 /*
@@ -4501,7 +4517,10 @@ job_set_options(job_T *job, jobopt_T *opt)
 		++job->jv_exit_partial->pt_refcount;
 	    }
 	    else
+	    {
 		job->jv_exit_cb = vim_strsave(opt->jo_exit_cb);
+		func_ref(job->jv_exit_cb);
+	    }
 	}
     }
 }

src/diff.c

@@ -135,7 +135,7 @@ diff_buf_add(buf_T *buf)
 	    return;
 	}
 
-    EMSGN(_("E96: Can not diff more than %ld buffers"), DB_COUNT);
+    EMSGN(_("E96: Cannot diff more than %ld buffers"), DB_COUNT);
 }
 
 /*

src/digraph.c

@@ -2460,4 +2460,3 @@ keymap_unload(void)
 }
 
 #endif /* FEAT_KEYMAP */
-

src/eval.c

@@ -2838,7 +2838,7 @@ do_unlet(char_u *name, int forceit)
 	}
 	hi = hash_find(ht, varname);
 	if (HASHITEM_EMPTY(hi))
-	    hi = find_hi_in_scoped_ht(name, &varname, &ht);
+	    hi = find_hi_in_scoped_ht(name, &ht);
 	if (hi != NULL && !HASHITEM_EMPTY(hi))
 	{
 	    di = HI2DI(hi);
@@ -5011,6 +5011,17 @@ get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate)
     return OK;
 }
 
+/*
+ * Return the function name of the partial.
+ */
+    char_u *
+partial_name(partial_T *pt)
+{
+    if (pt->pt_name != NULL)
+	return pt->pt_name;
+    return pt->pt_func->uf_name;
+}
+
     static void
 partial_free(partial_T *pt)
 {
@@ -5020,8 +5031,13 @@ partial_free(partial_T *pt)
 	clear_tv(&pt->pt_argv[i]);
     vim_free(pt->pt_argv);
     dict_unref(pt->pt_dict);
-    func_unref(pt->pt_name);
-    vim_free(pt->pt_name);
+    if (pt->pt_name != NULL)
+    {
+	func_unref(pt->pt_name);
+	vim_free(pt->pt_name);
+    }
+    else
+	func_ptr_unref(pt->pt_func);
     vim_free(pt);
 }
 
@@ -5051,11 +5067,11 @@ func_equal(
 
     /* empty and NULL function name considered the same */
     s1 = tv1->v_type == VAR_FUNC ? tv1->vval.v_string
-					   : tv1->vval.v_partial->pt_name;
+					   : partial_name(tv1->vval.v_partial);
     if (s1 != NULL && *s1 == NUL)
 	s1 = NULL;
     s2 = tv2->v_type == VAR_FUNC ? tv2->vval.v_string
-					   : tv2->vval.v_partial->pt_name;
+					   : partial_name(tv2->vval.v_partial);
     if (s2 != NULL && *s2 == NUL)
 	s2 = NULL;
     if (s1 == NULL || s2 == NULL)
@@ -5288,6 +5304,9 @@ garbage_collect(int testing)
     /* function-local variables */
     abort = abort || set_ref_in_call_stack(copyID);
 
+    /* named functions (matters for closures) */
+    abort = abort || set_ref_in_functions(copyID);
+
     /* function call arguments, if v:testing is set. */
     abort = abort || set_ref_in_func_args(copyID);
 
@@ -5550,7 +5569,7 @@ set_ref_in_item(
     }
     else if (tv->v_type == VAR_FUNC)
     {
-	abort = set_ref_in_func(tv->vval.v_string, copyID);
+	abort = set_ref_in_func(tv->vval.v_string, NULL, copyID);
     }
     else if (tv->v_type == VAR_PARTIAL)
     {
@@ -5561,7 +5580,7 @@ set_ref_in_item(
 	 */
 	if (pt != NULL)
 	{
-	    abort = set_ref_in_func(pt->pt_name, copyID);
+	    abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
 
 	    if (pt->pt_dict != NULL)
 	    {
@@ -5735,7 +5754,7 @@ echo_string_core(
 	    {
 		partial_T   *pt = tv->vval.v_partial;
 		char_u	    *fname = string_quote(pt == NULL ? NULL
-							: pt->pt_name, FALSE);
+						    : partial_name(pt), FALSE);
 		garray_T    ga;
 		int	    i;
 		char_u	    *tf;
@@ -6871,7 +6890,7 @@ handle_subscript(
 		if (functv.v_type == VAR_PARTIAL)
 		{
 		    pt = functv.vval.v_partial;
-		    s = pt->pt_name;
+		    s = partial_name(pt);
 		}
 		else
 		    s = functv.vval.v_string;
@@ -7328,8 +7347,7 @@ find_var(char_u *name, hashtab_T **htp, int no_autoload)
 	return ret;
 
     /* Search in parent scope for lambda */
-    return find_var_in_scoped_ht(name, varname ? &varname : NULL,
-		no_autoload || htp != NULL);
+    return find_var_in_scoped_ht(name, no_autoload || htp != NULL);
 }
 
 /*
@@ -7668,7 +7686,7 @@ set_var(
 
     /* Search in parent scope which is possible to reference from lambda */
     if (v == NULL)
-	v = find_var_in_scoped_ht(name, varname ? &varname : NULL, TRUE);
+	v = find_var_in_scoped_ht(name, TRUE);
 
     if ((tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
 				      && var_check_func_name(name, v == NULL))
@@ -7813,7 +7831,7 @@ var_check_func_name(
     /* Don't allow hiding a function.  When "v" is not NULL we might be
      * assigning another function to the same var, the type is checked
      * below. */
-    if (new_var && function_exists(name))
+    if (new_var && function_exists(name, FALSE))
     {
 	EMSG2(_("E705: Variable name conflicts with existing function: %s"),
 								    name);
@@ -10025,7 +10043,7 @@ filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
     {
 	partial_T   *partial = expr->vval.v_partial;
 
-	s = partial->pt_name;
+	s = partial_name(partial);
 	if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
 				  0L, 0L, &dummy, TRUE, partial, NULL) == FAIL)
 	    goto theend;