--- a/src/userfunc.c
+++ b/src/userfunc.c
@@ -14,52 +14,12 @@
 #include "vim.h"
 
 #if defined(FEAT_EVAL) || defined(PROTO)
-
-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 */
-    garray_T	uf_args;	/* arguments */
-    garray_T	uf_lines;	/* function lines */
-#ifdef FEAT_PROFILE
-    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 */
-#endif
-    scid_T	uf_script_ID;	/* ID of script where function was defined,
-				   used for s: variables */
-    int		uf_refcount;	/* for numbered function: reference count */
-    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) */
-};
-
 /* function flags */
 #define FC_ABORT    1		/* abort function on error */
 #define FC_RANGE    2		/* function accepts range */
 #define FC_DICT	    4		/* Dict function, uses "self" */
 #define FC_CLOSURE  8		/* closure, uses outer scope variables */
+#define FC_DELETED  16		/* :delfunction used while uf_refcount > 0 */
 
 /* From user function to hashitem and back. */
 #define UF2HIKEY(fp) ((fp)->uf_name)
@@ -69,52 +29,6 @@ struct ufunc
 #define FUNCARG(fp, j)	((char_u **)(fp->uf_args.ga_data))[j]
 #define FUNCLINE(fp, j)	((char_u **)(fp->uf_lines.ga_data))[j]
 
-#define MAX_FUNC_ARGS	20	/* maximum number of function arguments */
-#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 */
-#ifdef FEAT_PROFILE
-    proftime_T	prof_child;	/* time spent in a child */
-#endif
-    funccall_T	*caller;	/* calling function or NULL */
-
-    /* for closure */
-    int		fc_refcount;
-    int		fc_copyID;	/* for garbage collection */
-    garray_T	fc_funcs;	/* list of ufunc_T* which refer this */
-};
-
-/*
- * Struct 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;
-
 /*
  * All user-defined functions are found in this hashtable.
  */
@@ -271,7 +185,7 @@ register_closure(ufunc_T *fp)
 	return FAIL;
     ((ufunc_T **)current_funccal->fc_funcs.ga_data)
 	[current_funccal->fc_funcs.ga_len++] = fp;
-    func_ref(current_funccal->func->uf_name);
+    func_ptr_ref(current_funccal->func);
     return OK;
 }
 
@@ -288,7 +202,6 @@ get_lambda_tv(char_u **arg, typval_T *re
     ufunc_T	*fp = NULL;
     int		varargs;
     int		ret;
-    char_u	name[20];
     char_u	*start = skipwhite(*arg + 1);
     char_u	*s, *e;
     static int	lambda_no = 0;
@@ -331,14 +244,22 @@ get_lambda_tv(char_u **arg, typval_T *re
 
     if (evaluate)
     {
-	int	len, flags = 0;
-	char_u	*p;
+	int	    len, flags = 0;
+	char_u	    *p;
+	char_u	    name[20];
+	partial_T   *pt;
 
 	sprintf((char*)name, "<lambda>%d", ++lambda_no);
 
 	fp = (ufunc_T *)alloc_clear((unsigned)(sizeof(ufunc_T) + STRLEN(name)));
 	if (fp == NULL)
 	    goto errret;
+	pt = (partial_T *)alloc_clear((unsigned)sizeof(partial_T));
+	if (pt == NULL)
+	{
+	    vim_free(fp);
+	    goto errret;
+	}
 
 	ga_init2(&newlines, (int)sizeof(char_u *), 1);
 	if (ga_grow(&newlines, 1) == FAIL)
@@ -380,8 +301,10 @@ get_lambda_tv(char_u **arg, typval_T *re
 	fp->uf_calls = 0;
 	fp->uf_script_ID = current_SID;
 
-	rettv->vval.v_string = vim_strsave(name);
-	rettv->v_type = VAR_FUNC;
+	pt->pt_func = fp;
+	pt->pt_refcount = 1;
+	rettv->vval.v_partial = pt;
+	rettv->v_type = VAR_PARTIAL;
     }
 
     eval_lavars_used = old_eval_lavars;
@@ -406,6 +329,7 @@ deref_func_name(char_u *name, int *lenp,
 {
     dictitem_T	*v;
     int		cc;
+    char_u	*s;
 
     if (partialp != NULL)
 	*partialp = NULL;
@@ -421,8 +345,9 @@ deref_func_name(char_u *name, int *lenp,
 	    *lenp = 0;
 	    return (char_u *)"";	/* just in case */
 	}
-	*lenp = (int)STRLEN(v->di_tv.vval.v_string);
-	return v->di_tv.vval.v_string;
+	s = v->di_tv.vval.v_string;
+	*lenp = (int)STRLEN(s);
+	return s;
     }
 
     if (v != NULL && v->di_tv.v_type == VAR_PARTIAL)
@@ -436,8 +361,9 @@ deref_func_name(char_u *name, int *lenp,
 	}
 	if (partialp != NULL)
 	    *partialp = pt;
-	*lenp = (int)STRLEN(pt->pt_name);
-	return pt->pt_name;
+	s = partial_name(pt);
+	*lenp = (int)STRLEN(s);
+	return s;
     }
 
     return name;
@@ -611,7 +537,7 @@ fname_trans_sid(char_u *name, char_u *fn
  * Find a function by name, return pointer to it in ufuncs.
  * Return NULL for unknown function.
  */
-    static ufunc_T *
+    ufunc_T *
 find_func(char_u *name)
 {
     hashitem_T	*hi;
@@ -678,7 +604,7 @@ free_funccal(
 	     * funccall_T, don't clear it then. */
 	    if (fp->uf_scoped == fc)
 		fp->uf_scoped = NULL;
-	    func_unref(fc->func->uf_name);
+	    func_ptr_unref(fc->func);
 	}
     }
     ga_clear(&fc->fc_funcs);
@@ -695,7 +621,7 @@ free_funccal(
 	for (li = fc->l_varlist.lv_first; li != NULL; li = li->li_next)
 	    clear_tv(&li->li_tv);
 
-    func_unref(fc->func->uf_name);
+    func_ptr_unref(fc->func);
     vim_free(fc);
 }
 
@@ -759,7 +685,7 @@ call_user_func(
     fc->fc_refcount = 0;
     fc->fc_copyID = 0;
     ga_init2(&fc->fc_funcs, sizeof(ufunc_T *), 1);
-    func_ref(fp->uf_name);
+    func_ptr_ref(fp);
 
     if (STRNCMP(fp->uf_name, "<lambda>", 8) == 0)
 	islambda = TRUE;
@@ -1112,24 +1038,25 @@ funccal_unref(funccall_T *fc, ufunc_T *f
 
     if (--fc->fc_refcount <= 0)
     {
-	for (pfc = &previous_funccal; *pfc != NULL; )
+	for (pfc = &previous_funccal; *pfc != NULL; pfc = &(*pfc)->caller)
 	{
-	    if (fc == *pfc
-		    && fc->l_varlist.lv_refcount == DO_NOT_FREE_CNT
+	    if (fc == *pfc)
+	    {
+		if (fc->l_varlist.lv_refcount == DO_NOT_FREE_CNT
 		    && fc->l_vars.dv_refcount == DO_NOT_FREE_CNT
 		    && fc->l_avars.dv_refcount == DO_NOT_FREE_CNT)
-	    {
-		*pfc = fc->caller;
-		free_funccal(fc, TRUE);
-		freed = TRUE;
+		{
+		    *pfc = fc->caller;
+		    free_funccal(fc, TRUE);
+		    freed = TRUE;
+		}
+		break;
 	    }
-	    else
-		pfc = &(*pfc)->caller;
 	}
     }
     if (!freed)
     {
-	func_unref(fc->func->uf_name);
+	func_ptr_unref(fc->func);
 
 	if (fp != NULL)
 	    for (i = 0; i < fc->fc_funcs.ga_len; ++i)
@@ -1141,13 +1068,24 @@ funccal_unref(funccall_T *fc, ufunc_T *f
 }
 
 /*
+ * Remove the function from the function hashtable.  If the function was
+ * deleted while it still has references this was already done.
+ */
+    static void
+func_remove(ufunc_T *fp)
+{
+    hashitem_T	*hi = hash_find(&func_hashtab, UF2HIKEY(fp));
+
+    if (!HASHITEM_EMPTY(hi))
+	hash_remove(&func_hashtab, hi);
+}
+
+/*
  * Free a function and remove it from the list of functions.
  */
     static void
 func_free(ufunc_T *fp)
 {
-    hashitem_T	*hi;
-
     /* clear this function */
     ga_clear_strings(&(fp->uf_args));
     ga_clear_strings(&(fp->uf_lines));
@@ -1156,13 +1094,7 @@ func_free(ufunc_T *fp)
     vim_free(fp->uf_tml_total);
     vim_free(fp->uf_tml_self);
 #endif
-
-    /* remove the function from the function hashtable */
-    hi = hash_find(&func_hashtab, UF2HIKEY(fp));
-    if (HASHITEM_EMPTY(hi))
-	EMSG2(_(e_intern2), "func_free()");
-    else
-	hash_remove(&func_hashtab, hi);
+    func_remove(fp);
 
     funccal_unref(fp->uf_scoped, fp);
 
@@ -1333,7 +1265,10 @@ call_func(
 	    /*
 	     * User defined function.
 	     */
-	    fp = find_func(rfname);
+	    if (partial != NULL && partial->pt_func != NULL)
+		fp = partial->pt_func;
+	    else
+		fp = find_func(rfname);
 
 #ifdef FEAT_AUTOCMD
 	    /* Trigger FuncUndefined event, may load the function. */
@@ -1353,7 +1288,9 @@ call_func(
 		fp = find_func(rfname);
 	    }
 
-	    if (fp != NULL)
+	    if (fp != NULL && (fp->uf_flags & FC_DELETED))
+		error = ERROR_DELETED;
+	    else if (fp != NULL)
 	    {
 		if (argv_func != NULL)
 		    argcount = argv_func(argcount, argvars, fp->uf_args.ga_len);
@@ -1387,9 +1324,7 @@ call_func(
 		    call_user_func(fp, argcount, argvars, rettv,
 					       firstline, lastline,
 				  (fp->uf_flags & FC_DICT) ? selfdict : NULL);
-		    if (--fp->uf_calls <= 0 && (isdigit(*fp->uf_name)
-				|| STRNCMP(fp->uf_name, "<lambda>", 8) == 0)
-						      && fp->uf_refcount <= 0)
+		    if (--fp->uf_calls <= 0 && fp->uf_refcount <= 0)
 			/* Function was unreferenced while being used, free it
 			 * now. */
 			func_free(fp);
@@ -1433,6 +1368,9 @@ call_func(
 	    case ERROR_UNKNOWN:
 		    emsg_funcname(N_("E117: Unknown function: %s"), name);
 		    break;
+	    case ERROR_DELETED:
+		    emsg_funcname(N_("E933: Function was deleted: %s"), name);
+		    break;
 	    case ERROR_TOOMANY:
 		    emsg_funcname((char *)e_toomanyarg, name);
 		    break;
@@ -1516,7 +1454,7 @@ list_func_head(ufunc_T *fp, int indent)
  * TFN_NO_DEREF:    do not dereference a Funcref
  * Advances "pp" to just after the function name (if no error).
  */
-    static char_u *
+    char_u *
 trans_function_name(
     char_u	**pp,
     int		skip,		/* only find the end, don't evaluate */
@@ -1595,7 +1533,7 @@ trans_function_name(
 	else if (lv.ll_tv->v_type == VAR_PARTIAL
 					  && lv.ll_tv->vval.v_partial != NULL)
 	{
-	    name = vim_strsave(lv.ll_tv->vval.v_partial->pt_name);
+	    name = vim_strsave(partial_name(lv.ll_tv->vval.v_partial));
 	    *pp = end;
 	    if (partial != NULL)
 		*partial = lv.ll_tv->vval.v_partial;
@@ -1752,6 +1690,7 @@ ex_function(exarg_T *eap)
     int		varargs = FALSE;
     int		flags = 0;
     ufunc_T	*fp;
+    int		overwrite = FALSE;
     int		indent;
     int		nesting;
     char_u	*skip_until = NULL;
@@ -2214,11 +2153,22 @@ ex_function(exarg_T *eap)
 									name);
 		goto erret;
 	    }
-	    /* redefine existing function */
-	    ga_clear_strings(&(fp->uf_args));
-	    ga_clear_strings(&(fp->uf_lines));
-	    vim_free(name);
-	    name = NULL;
+	    if (fp->uf_refcount > 1)
+	    {
+		/* This function is referenced somewhere, don't redefine it but
+		 * create a new one. */
+		--fp->uf_refcount;
+		fp = NULL;
+		overwrite = TRUE;
+	    }
+	    else
+	    {
+		/* redefine existing function */
+		ga_clear_strings(&(fp->uf_args));
+		ga_clear_strings(&(fp->uf_lines));
+		vim_free(name);
+		name = NULL;
+	    }
 	}
     }
     else
@@ -2308,7 +2258,6 @@ ex_function(exarg_T *eap)
 	    fudi.fd_di->di_tv.v_type = VAR_FUNC;
 	    fudi.fd_di->di_tv.v_lock = 0;
 	    fudi.fd_di->di_tv.vval.v_string = vim_strsave(name);
-	    fp->uf_refcount = 1;
 
 	    /* behave like "dict" was used */
 	    flags |= FC_DICT;
@@ -2316,17 +2265,22 @@ ex_function(exarg_T *eap)
 
 	/* insert the new function in the function list */
 	STRCPY(fp->uf_name, name);
-	if (hash_add(&func_hashtab, UF2HIKEY(fp)) == FAIL)
+	if (overwrite)
+	{
+	    hi = hash_find(&func_hashtab, name);
+	    hi->hi_key = UF2HIKEY(fp);
+	}
+	else if (hash_add(&func_hashtab, UF2HIKEY(fp)) == FAIL)
 	{
 	    vim_free(fp);
 	    goto erret;
 	}
+	fp->uf_refcount = 1;
     }
     fp->uf_args = newargs;
     fp->uf_lines = newlines;
     if ((flags & FC_CLOSURE) != 0)
     {
-	++fp->uf_refcount;
 	if (register_closure(fp) == FAIL)
 	    goto erret;
     }
@@ -2750,13 +2704,30 @@ ex_delfunction(exarg_T *eap)
 	    dictitem_remove(fudi.fd_dict, fudi.fd_di);
 	}
 	else
-	    func_free(fp);
+	{
+	    /* Normal functions (not numbered functions and lambdas) have a
+	     * refcount of 1 for the entry in the hashtable.  When deleting
+	     * them and the refcount is more than one, it should be kept.
+	     * Numbered functions and lambdas snould be kept if the refcount is
+	     * one or more. */
+	    if (fp->uf_refcount > (isdigit(fp->uf_name[0])
+					     || fp->uf_name[0] == '<') ? 0 : 1)
+	    {
+		/* Function is still referenced somewhere.  Don't free it but
+		 * do remove it from the hashtable. */
+		func_remove(fp);
+		fp->uf_flags |= FC_DELETED;
+		fp->uf_refcount--;
+	    }
+	    else
+		func_free(fp);
+	}
     }
 }
 
 /*
  * Unreference a Function: decrement the reference count and free it when it
- * becomes zero.  Only for numbered functions.
+ * becomes zero.
  */
     void
 func_unref(char_u *name)
@@ -2765,22 +2736,30 @@ func_unref(char_u *name)
 
     if (name == NULL)
 	return;
-    if (isdigit(*name))
+    fp = find_func(name);
+    if (fp == NULL && isdigit(*name))
     {
-	fp = find_func(name);
-	if (fp == NULL)
-	{
 #ifdef EXITFREE
-	    if (!entered_free_all_mem)
+	if (!entered_free_all_mem)
 #endif
-		EMSG2(_(e_intern2), "func_unref()");
-	}
+	    EMSG2(_(e_intern2), "func_unref()");
+    }
+    if (fp != NULL && --fp->uf_refcount <= 0)
+    {
+	/* Only delete it when it's not being used.  Otherwise it's done
+	 * when "uf_calls" becomes zero. */
+	if (fp->uf_calls == 0)
+	    func_free(fp);
     }
-    else if (STRNCMP(name, "<lambda>", 8) == 0)
-    {
-	/* fail silently, when lambda function isn't found. */
-	fp = find_func(name);
-    }
+}
+
+/*
+ * Unreference a Function: decrement the reference count and free it when it
+ * becomes zero.
+ */
+    void
+func_ptr_unref(ufunc_T *fp)
+{
     if (fp != NULL && --fp->uf_refcount <= 0)
     {
 	/* Only delete it when it's not being used.  Otherwise it's done
@@ -2800,21 +2779,23 @@ func_ref(char_u *name)
 
     if (name == NULL)
 	return;
+    fp = find_func(name);
+    if (fp != NULL)
+	++fp->uf_refcount;
     else if (isdigit(*name))
-    {
-	fp = find_func(name);
-	if (fp == NULL)
-	    EMSG2(_(e_intern2), "func_ref()");
-	else
-	    ++fp->uf_refcount;
-    }
-    else if (STRNCMP(name, "<lambda>", 8) == 0)
-    {
-	/* fail silently, when lambda function isn't found. */
-	fp = find_func(name);
-	if (fp != NULL)
-	    ++fp->uf_refcount;
-    }
+	/* Only give an error for a numbered function.
+	 * Fail silently, when named or lambda function isn't found. */
+	EMSG2(_(e_intern2), "func_ref()");
+}
+
+/*
+ * Count a reference to a Function.
+ */
+    void
+func_ptr_ref(ufunc_T *fp)
+{
+    if (fp != NULL)
+	++fp->uf_refcount;
 }
 
 /*
@@ -3298,18 +3279,24 @@ func_has_abort(
     dict_T *
 make_partial(dict_T *selfdict_in, typval_T *rettv)
 {
-    char_u	*fname = rettv->v_type == VAR_FUNC ? rettv->vval.v_string
-					 : rettv->vval.v_partial->pt_name;
+    char_u	*fname;
     char_u	*tofree = NULL;
     ufunc_T	*fp;
     char_u	fname_buf[FLEN_FIXED + 1];
     int		error;
     dict_T	*selfdict = selfdict_in;
 
-    /* Translate "s:func" to the stored function name. */
-    fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
-    fp = find_func(fname);
-    vim_free(tofree);
+    if (rettv->v_type == VAR_PARTIAL && rettv->vval.v_partial->pt_func != NULL)
+	fp = rettv->vval.v_partial->pt_func;
+    else
+    {
+	fname = rettv->v_type == VAR_FUNC ? rettv->vval.v_string
+					      : rettv->vval.v_partial->pt_name;
+	/* Translate "s:func" to the stored function name. */
+	fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
+	fp = find_func(fname);
+	vim_free(tofree);
+    }
 
     if (fp != NULL && (fp->uf_flags & FC_DICT))
     {
@@ -3335,8 +3322,16 @@ make_partial(dict_T *selfdict_in, typval
 		/* Partial: copy the function name, use selfdict and copy
 		 * args.  Can't take over name or args, the partial might
 		 * be referenced elsewhere. */
-		pt->pt_name = vim_strsave(ret_pt->pt_name);
-		func_ref(pt->pt_name);
+		if (ret_pt->pt_name != NULL)
+		{
+		    pt->pt_name = vim_strsave(ret_pt->pt_name);
+		    func_ref(pt->pt_name);
+		}
+		else
+		{
+		    pt->pt_func = ret_pt->pt_func;
+		    func_ptr_ref(pt->pt_func);
+		}
 		if (ret_pt->pt_argc > 0)
 		{
 		    pt->pt_argv = (typval_T *)alloc(
@@ -3703,20 +3698,23 @@ set_ref_in_func_args(int copyID)
  * Returns TRUE if setting references failed somehow.
  */
     int
-set_ref_in_func(char_u *name, int copyID)
+set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
 {
-    ufunc_T	*fp;
+    ufunc_T	*fp = fp_in;
     funccall_T	*fc;
     int		error = ERROR_NONE;
     char_u	fname_buf[FLEN_FIXED + 1];
     char_u	*tofree = NULL;
     char_u	*fname;
 
-    if (name == NULL)
+    if (name == NULL && fp_in == NULL)
 	return FALSE;
 
-    fname = fname_trans_sid(name, fname_buf, &tofree, &error);
-    fp = find_func(fname);
+    if (fp_in == NULL)
+    {
+	fname = fname_trans_sid(name, fname_buf, &tofree, &error);
+	fp = find_func(fname);
+    }
     if (fp != NULL)
     {
 	for (fc = fp->uf_scoped; fc != NULL; fc = fc->func->uf_scoped)