To: vim_dev@googlegroups.com
Subject: Patch 8.2.4825
Fcc: outbox
From: Bram Moolenaar <Bram@moolenaar.net>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
------------

Patch 8.2.4825
Problem:    Can only get a list of mappings.
Solution:   Add the optional {abbr} argument. (Ernie Rael, closes #10277)
            Rename to maplist().  Rename test file.
Files:      runtime/doc/builtin.txt, runtime/doc/usr_41.txt, src/evalfunc.c,
            src/map.c, src/proto/map.pro, src/testdir/test_maparg.vim,
            src/testdir/test_map_functions.vim, src/testdir/Make_all.mak


*** ../vim-8.2.4824/runtime/doc/builtin.txt	2022-04-24 18:40:20.787116270 +0100
--- runtime/doc/builtin.txt	2022-04-25 14:25:44.622617201 +0100
***************
*** 235,241 ****
  getline({lnum}, {end})		List	lines {lnum} to {end} of current buffer
  getloclist({nr})		List	list of location list items
  getloclist({nr}, {what})	Dict	get specific location list properties
- getmappings()			List	list of all mappings, a dict for each
  getmarklist([{buf}])		List	list of global/local marks
  getmatches([{win}])		List	list of current matches
  getmousepos()			Dict	last known mouse position
--- 235,240 ----
***************
*** 338,343 ****
--- 337,343 ----
  					rhs of mapping {name} in mode {mode}
  mapcheck({name} [, {mode} [, {abbr}]])
  				String	check for mappings matching {name}
+ maplist([{abbr}])		List	list of all mappings, a dict for each
  mapnew({expr1}, {expr2})	List/Dict/Blob/String
  					like |map()| but creates a new List or
  					Dictionary
***************
*** 3557,3573 ****
  			:echo getloclist(5, {'filewinid': 0})
  
  
- getmappings()						*getmappings()*
- 		Returns a |List| of all mappings.  Each List item is a |Dict|,
- 		the same as what is returned by |maparg()|, see
- 		|mapping-dict|.
- 
- 		Example to show all mappings with 'MultiMatch' in rhs: >
- 			vim9script
- 			echo getmappings()->filter(
- 				(_, m) => match(m.rhs, 'MultiMatch') >= 0)
- 
- 
  getmarklist([{buf}])					*getmarklist()*
  		Without the {buf} argument returns a |List| with information
  		about all the global marks. |mark|
--- 3572,3577 ----
***************
*** 5229,5235 ****
  		When {dict} is omitted or zero: Return the rhs of mapping
  		{name} in mode {mode}.  The returned String has special
  		characters translated like in the output of the ":map" command
! 		listing.
  
  		When there is no mapping for {name}, an empty String is
  		returned.  When the mapping for {name} is empty, then "<Nop>"
--- 5237,5244 ----
  		When {dict} is omitted or zero: Return the rhs of mapping
  		{name} in mode {mode}.  The returned String has special
  		characters translated like in the output of the ":map" command
! 		listing. When {dict} is TRUE a dictionary is returned, see
! 		below. To get a list of all mappings see |maplist()|.
  
  		When there is no mapping for {name}, an empty String is
  		returned.  When the mapping for {name} is empty, then "<Nop>"
***************
*** 5288,5294 ****
  		then the global mappings.
  		This function can be used to map a key even when it's already
  		mapped, and have it do the original mapping too.  Sketch: >
! 			exe 'nnoremap <Tab> ==' . maparg('<Tab>', 'n')
  
  <		Can also be used as a |method|: >
  			GetKey()->maparg('n')
--- 5297,5303 ----
  		then the global mappings.
  		This function can be used to map a key even when it's already
  		mapped, and have it do the original mapping too.  Sketch: >
! 			exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
  
  <		Can also be used as a |method|: >
  			GetKey()->maparg('n')
***************
*** 5330,5335 ****
--- 5339,5356 ----
  			GetKey()->mapcheck('n')
  
  
+ maplist([{abbr}])					*maplist()*
+ 		Returns a |List| of all mappings.  Each List item is a |Dict|,
+ 		the same as what is returned by |maparg()|, see
+ 		|mapping-dict|.  When {abbr} is there and it is |TRUE| use
+ 		abbreviations instead of mappings.
+ 
+ 		Example to show all mappings with 'MultiMatch' in rhs: >
+ 			vim9script
+ 			echo maplist()->filter(
+ 				(_, m) => match(m.rhs, 'MultiMatch') >= 0)
+ 
+ 
  mapnew({expr1}, {expr2})					*mapnew()*
  		Like |map()| but instead of replacing items in {expr1} a new
  		List or Dictionary is created and returned.  {expr1} remains
*** ../vim-8.2.4824/runtime/doc/usr_41.txt	2022-04-24 18:40:20.787116270 +0100
--- runtime/doc/usr_41.txt	2022-04-25 14:26:33.198607690 +0100
***************
*** 998,1007 ****
  	digraph_getlist()	get all |digraph|s
  	digraph_set()		register |digraph|
  	digraph_setlist()	register multiple |digraph|s
- 	getmappings()		get list of all mappings
  	hasmapto()		check if a mapping exists
  	mapcheck()		check if a matching mapping exists
  	maparg()		get rhs of a mapping
  	mapset()		restore a mapping
  	menu_info()		get information about a menu item
  	wildmenumode()		check if the wildmode is active
--- 1089,1098 ----
  	digraph_getlist()	get all |digraph|s
  	digraph_set()		register |digraph|
  	digraph_setlist()	register multiple |digraph|s
  	hasmapto()		check if a mapping exists
  	mapcheck()		check if a matching mapping exists
  	maparg()		get rhs of a mapping
+ 	maplist()		get list of all mappings
  	mapset()		restore a mapping
  	menu_info()		get information about a menu item
  	wildmenumode()		check if the wildmode is active
*** ../vim-8.2.4824/src/evalfunc.c	2022-04-24 18:40:20.791116268 +0100
--- src/evalfunc.c	2022-04-25 14:23:51.382628791 +0100
***************
*** 1871,1878 ****
  			ret_getline,	    f_getline},
      {"getloclist",	1, 2, 0,	    arg2_number_dict_any,
  			ret_list_or_dict_1, f_getloclist},
-     {"getmappings",		0, 0, 0,	    NULL,
- 			ret_list_dict_any,  f_getmappings},
      {"getmarklist",	0, 1, FEARG_1,	    arg1_buffer,
  			ret_list_dict_any,  f_getmarklist},
      {"getmatches",	0, 1, 0,	    arg1_number,
--- 1871,1876 ----
***************
*** 2049,2054 ****
--- 2047,2054 ----
  			ret_maparg,	    f_maparg},
      {"mapcheck",	1, 3, FEARG_1,	    arg3_string_string_bool,
  			ret_string,	    f_mapcheck},
+     {"maplist",		0, 1, 0,	    arg1_bool,
+ 			ret_list_dict_any,  f_maplist},
      {"mapnew",		2, 2, FEARG_1,	    arg2_mapnew,
  			ret_first_cont,	    f_mapnew},
      {"mapset",		3, 3, FEARG_1,	    arg3_string_bool_dict,
*** ../vim-8.2.4824/src/map.c	2022-04-25 13:27:56.757032651 +0100
--- src/map.c	2022-04-25 14:24:09.290628026 +0100
***************
*** 2389,2398 ****
  }
  
  /*
!  * "getmappings()" function
   */
      void
! f_getmappings(typval_T *argvars UNUSED, typval_T *rettv)
  {
      dict_T	*d;
      mapblock_T	*mp;
--- 2389,2398 ----
  }
  
  /*
!  * "maplist()" function
   */
      void
! f_maplist(typval_T *argvars UNUSED, typval_T *rettv)
  {
      dict_T	*d;
      mapblock_T	*mp;
***************
*** 2402,2407 ****
--- 2402,2413 ----
      int		hash;
      char_u	*lhs;
      const int	flags = REPTERM_FROM_PART | REPTERM_DO_LT;
+     int		abbr = FALSE;
+ 
+     if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
+ 	return;
+     if (argvars[0].v_type != VAR_UNKNOWN)
+ 	abbr = tv_get_bool(&argvars[0]);
  
      if (rettv_list_alloc(rettv) != OK)
  	return;
***************
*** 2413,2419 ****
      {
  	for (hash = 0; hash < 256; ++hash)
  	{
! 	    if (buffer_local)
  		mp = curbuf->b_maphash[hash];
  	    else
  		mp = maphash[hash];
--- 2419,2434 ----
      {
  	for (hash = 0; hash < 256; ++hash)
  	{
! 	    if (abbr)
! 	    {
! 		if (hash > 0)		// there is only one abbr list
! 		    break;
! 		if (buffer_local)
! 		    mp = curbuf->b_first_abbr;
! 		else
! 		    mp = first_abbr;
! 	    }
! 	    else if (buffer_local)
  		mp = curbuf->b_maphash[hash];
  	    else
  		mp = maphash[hash];
*** ../vim-8.2.4824/src/proto/map.pro	2022-04-24 18:40:20.791116268 +0100
--- src/proto/map.pro	2022-04-25 14:27:21.506595907 +0100
***************
*** 8,14 ****
  int map_to_exists(char_u *str, char_u *modechars, int abbr);
  int map_to_exists_mode(char_u *rhs, int mode, int abbr);
  char_u *set_context_in_map_cmd(expand_T *xp, char_u *cmd, char_u *arg, int forceit, int isabbrev, int isunmap, cmdidx_T cmdidx);
! int ExpandMappings(char_u *pat, regmatch_T *regmatch, int *num_file, char_u ***file);
  int check_abbr(int c, char_u *ptr, int col, int mincol);
  char_u *eval_map_expr(mapblock_T *mp, int c);
  char_u *vim_strsave_escape_csi(char_u *p);
--- 8,14 ----
  int map_to_exists(char_u *str, char_u *modechars, int abbr);
  int map_to_exists_mode(char_u *rhs, int mode, int abbr);
  char_u *set_context_in_map_cmd(expand_T *xp, char_u *cmd, char_u *arg, int forceit, int isabbrev, int isunmap, cmdidx_T cmdidx);
! int ExpandMappings(char_u *pat, regmatch_T *regmatch, int *numMatches, char_u ***matches);
  int check_abbr(int c, char_u *ptr, int col, int mincol);
  char_u *eval_map_expr(mapblock_T *mp, int c);
  char_u *vim_strsave_escape_csi(char_u *p);
***************
*** 17,23 ****
  int put_escstr(FILE *fd, char_u *strstart, int what);
  void check_map_keycodes(void);
  char_u *check_map(char_u *keys, int mode, int exact, int ign_mod, int abbr, mapblock_T **mp_ptr, int *local_ptr);
! void f_getmappings(typval_T *argvars, typval_T *rettv);
  void f_maparg(typval_T *argvars, typval_T *rettv);
  void f_mapcheck(typval_T *argvars, typval_T *rettv);
  void f_mapset(typval_T *argvars, typval_T *rettv);
--- 17,23 ----
  int put_escstr(FILE *fd, char_u *strstart, int what);
  void check_map_keycodes(void);
  char_u *check_map(char_u *keys, int mode, int exact, int ign_mod, int abbr, mapblock_T **mp_ptr, int *local_ptr);
! void f_maplist(typval_T *argvars, typval_T *rettv);
  void f_maparg(typval_T *argvars, typval_T *rettv);
  void f_mapcheck(typval_T *argvars, typval_T *rettv);
  void f_mapset(typval_T *argvars, typval_T *rettv);
*** ../vim-8.2.4824/src/testdir/test_maparg.vim	2022-04-24 18:40:20.791116268 +0100
--- src/testdir/test_maparg.vim	1970-01-01 00:00:00.000000000 +0000
***************
*** 1,372 ****
- " Tests for maparg(), mapcheck() and mapset().
- " Also test utf8 map with a 0x80 byte.
- " Also test mapcheck()
- 
- func s:SID()     
-   return str2nr(matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$'))
- endfunc
- 
- func Test_maparg()
-   new
-   set cpo-=<
-   set encoding=utf8
-   " Test maparg() with a string result
-   let sid = s:SID()
-   let lnum = expand('<sflnum>')
-   map foo<C-V> is<F4>foo
-   vnoremap <script> <buffer> <expr> <silent> bar isbar
-   call assert_equal("is<F4>foo", maparg('foo<C-V>'))
-   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo<C-V>',
-         \ 'lhsraw': "foo\x80\xfc\x04V", 'lhsrawalt': "foo\x16",
-         \ 'mode': ' ', 'nowait': 0, 'expr': 0, 'sid': sid, 'scriptversion': 1,
-         \ 'lnum': lnum + 1, 
- 	\ 'rhs': 'is<F4>foo', 'buffer': 0},
- 	\ maparg('foo<C-V>', '', 0, 1))
-   call assert_equal({'silent': 1, 'noremap': 1, 'script': 1, 'lhs': 'bar',
-         \ 'lhsraw': 'bar', 'mode': 'v',
-         \ 'nowait': 0, 'expr': 1, 'sid': sid, 'scriptversion': 1,
-         \ 'lnum': lnum + 2,
- 	\ 'rhs': 'isbar', 'buffer': 1},
-         \ 'bar'->maparg('', 0, 1))
-   let lnum = expand('<sflnum>')
-   map <buffer> <nowait> foo bar
-   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo',
-         \ 'lhsraw': 'foo', 'mode': ' ',
-         \ 'nowait': 1, 'expr': 0, 'sid': sid, 'scriptversion': 1,
-         \ 'lnum': lnum + 1, 'rhs': 'bar',
- 	\ 'buffer': 1},
-         \ maparg('foo', '', 0, 1))
-   let lnum = expand('<sflnum>')
-   tmap baz foo
-   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'baz',
-         \ 'lhsraw': 'baz', 'mode': 't',
-         \ 'nowait': 0, 'expr': 0, 'sid': sid, 'scriptversion': 1,
-         \ 'lnum': lnum + 1, 'rhs': 'foo',
- 	\ 'buffer': 0},
-         \ maparg('baz', 't', 0, 1))
- 
-   map abc x<char-114>x
-   call assert_equal("xrx", maparg('abc'))
-   map abc y<S-char-114>y
-   call assert_equal("yRy", maparg('abc'))
- 
-   omap { w
-   let d = maparg('{', 'o', 0, 1)
-   call assert_equal(['{', 'w', 'o'], [d.lhs, d.rhs, d.mode])
-   ounmap {
- 
-   lmap { w
-   let d = maparg('{', 'l', 0, 1)
-   call assert_equal(['{', 'w', 'l'], [d.lhs, d.rhs, d.mode])
-   lunmap {
- 
-   nmap { w
-   let d = maparg('{', 'n', 0, 1)
-   call assert_equal(['{', 'w', 'n'], [d.lhs, d.rhs, d.mode])
-   nunmap {
- 
-   xmap { w
-   let d = maparg('{', 'x', 0, 1)
-   call assert_equal(['{', 'w', 'x'], [d.lhs, d.rhs, d.mode])
-   xunmap {
- 
-   smap { w
-   let d = maparg('{', 's', 0, 1)
-   call assert_equal(['{', 'w', 's'], [d.lhs, d.rhs, d.mode])
-   sunmap {
- 
-   map abc <Nop>
-   call assert_equal("<Nop>", maparg('abc'))
-   unmap abc
- 
-   call feedkeys(":abbr esc \<C-V>\<C-V>\<C-V>\<C-V>\<C-V>\<Esc>\<CR>", "xt")
-   let d = maparg('esc', 'i', 1, 1)
-   call assert_equal(['esc', "\<C-V>\<C-V>\<Esc>", '!'], [d.lhs, d.rhs, d.mode])
-   abclear
- endfunc
- 
- def Test_vim9_maparg()
-   nmap { w
-   var one: string = maparg('{')
-   assert_equal('w', one)
-   var two: string = maparg('{', 'n')
-   assert_equal('w', two)
-   var three: string = maparg('{', 'n', 0)
-   assert_equal('w', three)
-   var four: dict<any> = maparg('{', 'n', 0, 1)
-   assert_equal(['{', 'w', 'n'], [four.lhs, four.rhs, four.mode])
-   nunmap {
- enddef
- 
- func Test_mapcheck()
-   call assert_equal('', mapcheck('a'))
-   call assert_equal('', mapcheck('abc'))
-   call assert_equal('', mapcheck('ax'))
-   call assert_equal('', mapcheck('b'))
- 
-   map a something
-   call assert_equal('something', mapcheck('a'))
-   call assert_equal('something', mapcheck('a', 'n'))
-   call assert_equal('', mapcheck('a', 'c'))
-   call assert_equal('', mapcheck('a', 'i'))
-   call assert_equal('something', 'abc'->mapcheck())
-   call assert_equal('something', 'ax'->mapcheck())
-   call assert_equal('', mapcheck('b'))
-   unmap a
- 
-   map ab foobar
-   call assert_equal('foobar', mapcheck('a'))
-   call assert_equal('foobar', mapcheck('abc'))
-   call assert_equal('', mapcheck('ax'))
-   call assert_equal('', mapcheck('b'))
-   unmap ab
- 
-   map abc barfoo
-   call assert_equal('barfoo', mapcheck('a'))
-   call assert_equal('barfoo', mapcheck('a', 'n', 0))
-   call assert_equal('', mapcheck('a', 'n', 1))
-   call assert_equal('barfoo', mapcheck('abc'))
-   call assert_equal('', mapcheck('ax'))
-   call assert_equal('', mapcheck('b'))
-   unmap abc
- 
-   abbr ab abbrev
-   call assert_equal('abbrev', mapcheck('a', 'i', 1))
-   call assert_equal('', mapcheck('a', 'n', 1))
-   call assert_equal('', mapcheck('a', 'i', 0))
-   unabbr ab
- endfunc
- 
- func Test_range_map()
-   new
-   " Outside of the range, minimum
-   inoremap <Char-0x1040> a
-   execute "normal a\u1040\<Esc>"
-   " Inside of the range, minimum
-   inoremap <Char-0x103f> b
-   execute "normal a\u103f\<Esc>"
-   " Inside of the range, maximum
-   inoremap <Char-0xf03f> c
-   execute "normal a\uf03f\<Esc>"
-   " Outside of the range, maximum
-   inoremap <Char-0xf040> d
-   execute "normal a\uf040\<Esc>"
-   call assert_equal("abcd", getline(1))
- endfunc
- 
- func One_mapset_test(keys)
-   exe 'nnoremap ' .. a:keys .. ' original<CR>'
-   let orig = maparg(a:keys, 'n', 0, 1)
-   call assert_equal(a:keys, orig.lhs)
-   call assert_equal('original<CR>', orig.rhs)
-   call assert_equal('n', orig.mode)
- 
-   exe 'nunmap ' .. a:keys
-   let d = maparg(a:keys, 'n', 0, 1)
-   call assert_equal({}, d)
- 
-   call mapset('n', 0, orig)
-   let d = maparg(a:keys, 'n', 0, 1)
-   call assert_equal(a:keys, d.lhs)
-   call assert_equal('original<CR>', d.rhs)
-   call assert_equal('n', d.mode)
- 
-   exe 'nunmap ' .. a:keys
- endfunc
- 
- func Test_mapset()
-   call One_mapset_test('K')
-   call One_mapset_test('<F3>')
- 
-   " Check <> key conversion
-   new
-   inoremap K one<Left>x
-   call feedkeys("iK\<Esc>", 'xt')
-   call assert_equal('onxe', getline(1))
- 
-   let orig = maparg('K', 'i', 0, 1)
-   call assert_equal('K', orig.lhs)
-   call assert_equal('one<Left>x', orig.rhs)
-   call assert_equal('i', orig.mode)
- 
-   iunmap K
-   let d = maparg('K', 'i', 0, 1)
-   call assert_equal({}, d)
- 
-   call mapset('i', 0, orig)
-   call feedkeys("SK\<Esc>", 'xt')
-   call assert_equal('onxe', getline(1))
- 
-   iunmap K
- 
-   " Test literal <CR> using a backslash
-   let cpo_save = &cpo
-   set cpo-=B
-   inoremap K one\<CR>two
-   call feedkeys("SK\<Esc>", 'xt')
-   call assert_equal('one<CR>two', getline(1))
- 
-   let orig = maparg('K', 'i', 0, 1)
-   call assert_equal('K', orig.lhs)
-   call assert_equal('one\<CR>two', orig.rhs)
-   call assert_equal('i', orig.mode)
- 
-   iunmap K
-   let d = maparg('K', 'i', 0, 1)
-   call assert_equal({}, d)
- 
-   call mapset('i', 0, orig)
-   call feedkeys("SK\<Esc>", 'xt')
-   call assert_equal('one<CR>two', getline(1))
- 
-   iunmap K
- 
-   " Test literal <CR> using CTRL-V
-   inoremap K one<CR>two
-   call feedkeys("SK\<Esc>", 'xt')
-   call assert_equal('one<CR>two', getline(1))
- 
-   let orig = maparg('K', 'i', 0, 1)
-   call assert_equal('K', orig.lhs)
-   call assert_equal("one\x16<CR>two", orig.rhs)
-   call assert_equal('i', orig.mode)
- 
-   iunmap K
-   let d = maparg('K', 'i', 0, 1)
-   call assert_equal({}, d)
- 
-   call mapset('i', 0, orig)
-   call feedkeys("SK\<Esc>", 'xt')
-   call assert_equal('one<CR>two', getline(1))
- 
-   iunmap K
-   let &cpo = cpo_save
-   bwipe!
- 
-   call assert_fails('call mapset([], v:false, {})', 'E730:')
-   call assert_fails('call mapset("i", 0, "")', 'E716:')
-   call assert_fails('call mapset("i", 0, {})', 'E460:')
- endfunc
- 
- func Check_ctrlb_map(d, check_alt)
-   call assert_equal('<C-B>', a:d.lhs)
-   if a:check_alt
-     call assert_equal("\x80\xfc\x04B", a:d.lhsraw)
-     call assert_equal("\x02", a:d.lhsrawalt)
-   else
-     call assert_equal("\x02", a:d.lhsraw)
-   endif
- endfunc
- 
- func Test_map_local()
-   nmap a global
-   nmap <buffer>a local
- 
-   let prev_map_list = split(execute('nmap a'), "\n")
-   call assert_match('n\s*a\s*@local', prev_map_list[0])
-   call assert_match('n\s*a\s*global', prev_map_list[1])
- 
-   let mapping = maparg('a', 'n', 0, 1)
-   call assert_equal(1, mapping.buffer)
-   let mapping.rhs = 'new_local'
-   call mapset('n', 0, mapping)
- 
-   " Check that the global mapping is left untouched.
-   let map_list = split(execute('nmap a'), "\n")
-   call assert_match('n\s*a\s*@new_local', map_list[0])
-   call assert_match('n\s*a\s*global', map_list[1])
- 
-   nunmap a
- endfunc
- 
- func Test_map_restore()
-   " Test restoring map with alternate keycode
-   nmap <C-B> back
-   let d = maparg('<C-B>', 'n', 0, 1)
-   call Check_ctrlb_map(d, 1)
-   let dsimp = maparg("\x02", 'n', 0, 1)
-   call Check_ctrlb_map(dsimp, 0)
-   nunmap <C-B>
-   call mapset('n', 0, d)
-   let d = maparg('<C-B>', 'n', 0, 1)
-   call Check_ctrlb_map(d, 1)
-   let dsimp = maparg("\x02", 'n', 0, 1)
-   call Check_ctrlb_map(dsimp, 0)
- 
-   nunmap <C-B>
- 
- endfunc
- 
- def Test_getmappings()
-   new
-   def ClearMaps()
-     mapclear | nmapclear | vmapclear | xmapclear | smapclear | omapclear
-     mapclear!  | imapclear | lmapclear | cmapclear | tmapclear
-     mapclear <buffer> | nmapclear <buffer> | vmapclear <buffer>
-     xmapclear <buffer> | smapclear <buffer> | omapclear <buffer>
-     mapclear! <buffer> | imapclear <buffer> | lmapclear <buffer>
-     cmapclear <buffer> | tmapclear <buffer>
-   enddef
- 
-   def AddMaps(new: list<string>, accum: list<string>)
-     if len(new) > 0 && new[0] != "No mapping found"
-       accum->extend(new)
-     endif
-   enddef
- 
-   ClearMaps()
-   assert_equal(0, len(getmappings()))
- 
-   # Set up some mappings.
-   map dup bar
-   map <buffer> dup bufbar
-   map foo<C-V> is<F4>foo
-   vnoremap <script> <buffer> <expr> <silent> bar isbar
-   tmap baz foo
-   omap h w
-   lmap i w
-   nmap j w
-   xmap k w
-   smap l w
-   map abc <Nop>
-   nmap <M-j> x
-   nmap <M-Space> y
- 
-   # Get a list of the mappings with the ':map' commands.
-   # Check getmappings() return a list of the same size.
-   assert_equal(13, len(getmappings()))
- 
-   # collect all the current maps using :map commands
-   var maps_command: list<string>
-   AddMaps(split(execute('map'), '\n'), maps_command)
-   AddMaps(split(execute('map!'), '\n'), maps_command)
-   AddMaps(split(execute('tmap'), '\n'), maps_command)
-   AddMaps(split(execute('lmap'), '\n'), maps_command)
- 
-   # Use getmappings to get all the maps
-   var maps_getmappings = getmappings()
-   assert_equal(len(maps_command), len(maps_getmappings))
- 
-   # make sure all the mode-lhs are unique, no duplicates
-   var map_set: dict<number>
-   for d in maps_getmappings
-     map_set[d.mode .. "-" .. d.lhs .. "-" .. d.buffer] = 0
-   endfor
-   assert_equal(len(maps_getmappings), len(map_set))
- 
-   # For everything returned by getmappings, should be the same as from maparg.
-   # Except for "map dup", bacause maparg returns the <buffer> version
-   for d in maps_getmappings
-     if d.lhs == 'dup' && d.buffer == 0
-       continue
-     endif
-     var d_maparg = maparg(d.lhs, d.mode, false, true)
-     assert_equal(d_maparg, d)
-   endfor
- 
-   ClearMaps()
-   assert_equal(0, len(getmappings()))
- enddef
- 
- 
- " vim: shiftwidth=2 sts=2 expandtab
--- 0 ----
*** ../vim-8.2.4824/src/testdir/test_map_functions.vim	2022-04-25 14:36:20.914355987 +0100
--- src/testdir/test_map_functions.vim	2022-04-25 14:22:18.070625211 +0100
***************
*** 0 ****
--- 1,387 ----
+ " Tests for maparg(), mapcheck(), mapset(), maplist()
+ " Also test utf8 map with a 0x80 byte.
+ 
+ func s:SID()     
+   return str2nr(matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$'))
+ endfunc
+ 
+ func Test_maparg()
+   new
+   set cpo-=<
+   set encoding=utf8
+   " Test maparg() with a string result
+   let sid = s:SID()
+   let lnum = expand('<sflnum>')
+   map foo<C-V> is<F4>foo
+   vnoremap <script> <buffer> <expr> <silent> bar isbar
+   call assert_equal("is<F4>foo", maparg('foo<C-V>'))
+   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo<C-V>',
+         \ 'lhsraw': "foo\x80\xfc\x04V", 'lhsrawalt': "foo\x16",
+         \ 'mode': ' ', 'nowait': 0, 'expr': 0, 'sid': sid, 'scriptversion': 1,
+         \ 'lnum': lnum + 1, 
+ 	\ 'rhs': 'is<F4>foo', 'buffer': 0},
+ 	\ maparg('foo<C-V>', '', 0, 1))
+   call assert_equal({'silent': 1, 'noremap': 1, 'script': 1, 'lhs': 'bar',
+         \ 'lhsraw': 'bar', 'mode': 'v',
+         \ 'nowait': 0, 'expr': 1, 'sid': sid, 'scriptversion': 1,
+         \ 'lnum': lnum + 2,
+ 	\ 'rhs': 'isbar', 'buffer': 1},
+         \ 'bar'->maparg('', 0, 1))
+   let lnum = expand('<sflnum>')
+   map <buffer> <nowait> foo bar
+   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo',
+         \ 'lhsraw': 'foo', 'mode': ' ',
+         \ 'nowait': 1, 'expr': 0, 'sid': sid, 'scriptversion': 1,
+         \ 'lnum': lnum + 1, 'rhs': 'bar',
+ 	\ 'buffer': 1},
+         \ maparg('foo', '', 0, 1))
+   let lnum = expand('<sflnum>')
+   tmap baz foo
+   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'baz',
+         \ 'lhsraw': 'baz', 'mode': 't',
+         \ 'nowait': 0, 'expr': 0, 'sid': sid, 'scriptversion': 1,
+         \ 'lnum': lnum + 1, 'rhs': 'foo',
+ 	\ 'buffer': 0},
+         \ maparg('baz', 't', 0, 1))
+ 
+   map abc x<char-114>x
+   call assert_equal("xrx", maparg('abc'))
+   map abc y<S-char-114>y
+   call assert_equal("yRy", maparg('abc'))
+ 
+   omap { w
+   let d = maparg('{', 'o', 0, 1)
+   call assert_equal(['{', 'w', 'o'], [d.lhs, d.rhs, d.mode])
+   ounmap {
+ 
+   lmap { w
+   let d = maparg('{', 'l', 0, 1)
+   call assert_equal(['{', 'w', 'l'], [d.lhs, d.rhs, d.mode])
+   lunmap {
+ 
+   nmap { w
+   let d = maparg('{', 'n', 0, 1)
+   call assert_equal(['{', 'w', 'n'], [d.lhs, d.rhs, d.mode])
+   nunmap {
+ 
+   xmap { w
+   let d = maparg('{', 'x', 0, 1)
+   call assert_equal(['{', 'w', 'x'], [d.lhs, d.rhs, d.mode])
+   xunmap {
+ 
+   smap { w
+   let d = maparg('{', 's', 0, 1)
+   call assert_equal(['{', 'w', 's'], [d.lhs, d.rhs, d.mode])
+   sunmap {
+ 
+   map abc <Nop>
+   call assert_equal("<Nop>", maparg('abc'))
+   unmap abc
+ 
+   call feedkeys(":abbr esc \<C-V>\<C-V>\<C-V>\<C-V>\<C-V>\<Esc>\<CR>", "xt")
+   let d = maparg('esc', 'i', 1, 1)
+   call assert_equal(['esc', "\<C-V>\<C-V>\<Esc>", '!'], [d.lhs, d.rhs, d.mode])
+   abclear
+ endfunc
+ 
+ def Test_vim9_maparg()
+   nmap { w
+   var one: string = maparg('{')
+   assert_equal('w', one)
+   var two: string = maparg('{', 'n')
+   assert_equal('w', two)
+   var three: string = maparg('{', 'n', 0)
+   assert_equal('w', three)
+   var four: dict<any> = maparg('{', 'n', 0, 1)
+   assert_equal(['{', 'w', 'n'], [four.lhs, four.rhs, four.mode])
+   nunmap {
+ enddef
+ 
+ func Test_mapcheck()
+   call assert_equal('', mapcheck('a'))
+   call assert_equal('', mapcheck('abc'))
+   call assert_equal('', mapcheck('ax'))
+   call assert_equal('', mapcheck('b'))
+ 
+   map a something
+   call assert_equal('something', mapcheck('a'))
+   call assert_equal('something', mapcheck('a', 'n'))
+   call assert_equal('', mapcheck('a', 'c'))
+   call assert_equal('', mapcheck('a', 'i'))
+   call assert_equal('something', 'abc'->mapcheck())
+   call assert_equal('something', 'ax'->mapcheck())
+   call assert_equal('', mapcheck('b'))
+   unmap a
+ 
+   map ab foobar
+   call assert_equal('foobar', mapcheck('a'))
+   call assert_equal('foobar', mapcheck('abc'))
+   call assert_equal('', mapcheck('ax'))
+   call assert_equal('', mapcheck('b'))
+   unmap ab
+ 
+   map abc barfoo
+   call assert_equal('barfoo', mapcheck('a'))
+   call assert_equal('barfoo', mapcheck('a', 'n', 0))
+   call assert_equal('', mapcheck('a', 'n', 1))
+   call assert_equal('barfoo', mapcheck('abc'))
+   call assert_equal('', mapcheck('ax'))
+   call assert_equal('', mapcheck('b'))
+   unmap abc
+ 
+   abbr ab abbrev
+   call assert_equal('abbrev', mapcheck('a', 'i', 1))
+   call assert_equal('', mapcheck('a', 'n', 1))
+   call assert_equal('', mapcheck('a', 'i', 0))
+   unabbr ab
+ endfunc
+ 
+ func Test_range_map()
+   new
+   " Outside of the range, minimum
+   inoremap <Char-0x1040> a
+   execute "normal a\u1040\<Esc>"
+   " Inside of the range, minimum
+   inoremap <Char-0x103f> b
+   execute "normal a\u103f\<Esc>"
+   " Inside of the range, maximum
+   inoremap <Char-0xf03f> c
+   execute "normal a\uf03f\<Esc>"
+   " Outside of the range, maximum
+   inoremap <Char-0xf040> d
+   execute "normal a\uf040\<Esc>"
+   call assert_equal("abcd", getline(1))
+ endfunc
+ 
+ func One_mapset_test(keys)
+   exe 'nnoremap ' .. a:keys .. ' original<CR>'
+   let orig = maparg(a:keys, 'n', 0, 1)
+   call assert_equal(a:keys, orig.lhs)
+   call assert_equal('original<CR>', orig.rhs)
+   call assert_equal('n', orig.mode)
+ 
+   exe 'nunmap ' .. a:keys
+   let d = maparg(a:keys, 'n', 0, 1)
+   call assert_equal({}, d)
+ 
+   call mapset('n', 0, orig)
+   let d = maparg(a:keys, 'n', 0, 1)
+   call assert_equal(a:keys, d.lhs)
+   call assert_equal('original<CR>', d.rhs)
+   call assert_equal('n', d.mode)
+ 
+   exe 'nunmap ' .. a:keys
+ endfunc
+ 
+ func Test_mapset()
+   call One_mapset_test('K')
+   call One_mapset_test('<F3>')
+ 
+   " Check <> key conversion
+   new
+   inoremap K one<Left>x
+   call feedkeys("iK\<Esc>", 'xt')
+   call assert_equal('onxe', getline(1))
+ 
+   let orig = maparg('K', 'i', 0, 1)
+   call assert_equal('K', orig.lhs)
+   call assert_equal('one<Left>x', orig.rhs)
+   call assert_equal('i', orig.mode)
+ 
+   iunmap K
+   let d = maparg('K', 'i', 0, 1)
+   call assert_equal({}, d)
+ 
+   call mapset('i', 0, orig)
+   call feedkeys("SK\<Esc>", 'xt')
+   call assert_equal('onxe', getline(1))
+ 
+   iunmap K
+ 
+   " Test literal <CR> using a backslash
+   let cpo_save = &cpo
+   set cpo-=B
+   inoremap K one\<CR>two
+   call feedkeys("SK\<Esc>", 'xt')
+   call assert_equal('one<CR>two', getline(1))
+ 
+   let orig = maparg('K', 'i', 0, 1)
+   call assert_equal('K', orig.lhs)
+   call assert_equal('one\<CR>two', orig.rhs)
+   call assert_equal('i', orig.mode)
+ 
+   iunmap K
+   let d = maparg('K', 'i', 0, 1)
+   call assert_equal({}, d)
+ 
+   call mapset('i', 0, orig)
+   call feedkeys("SK\<Esc>", 'xt')
+   call assert_equal('one<CR>two', getline(1))
+ 
+   iunmap K
+ 
+   " Test literal <CR> using CTRL-V
+   inoremap K one<CR>two
+   call feedkeys("SK\<Esc>", 'xt')
+   call assert_equal('one<CR>two', getline(1))
+ 
+   let orig = maparg('K', 'i', 0, 1)
+   call assert_equal('K', orig.lhs)
+   call assert_equal("one\x16<CR>two", orig.rhs)
+   call assert_equal('i', orig.mode)
+ 
+   iunmap K
+   let d = maparg('K', 'i', 0, 1)
+   call assert_equal({}, d)
+ 
+   call mapset('i', 0, orig)
+   call feedkeys("SK\<Esc>", 'xt')
+   call assert_equal('one<CR>two', getline(1))
+ 
+   iunmap K
+   let &cpo = cpo_save
+   bwipe!
+ 
+   call assert_fails('call mapset([], v:false, {})', 'E730:')
+   call assert_fails('call mapset("i", 0, "")', 'E716:')
+   call assert_fails('call mapset("i", 0, {})', 'E460:')
+ endfunc
+ 
+ func Check_ctrlb_map(d, check_alt)
+   call assert_equal('<C-B>', a:d.lhs)
+   if a:check_alt
+     call assert_equal("\x80\xfc\x04B", a:d.lhsraw)
+     call assert_equal("\x02", a:d.lhsrawalt)
+   else
+     call assert_equal("\x02", a:d.lhsraw)
+   endif
+ endfunc
+ 
+ func Test_map_local()
+   nmap a global
+   nmap <buffer>a local
+ 
+   let prev_map_list = split(execute('nmap a'), "\n")
+   call assert_match('n\s*a\s*@local', prev_map_list[0])
+   call assert_match('n\s*a\s*global', prev_map_list[1])
+ 
+   let mapping = maparg('a', 'n', 0, 1)
+   call assert_equal(1, mapping.buffer)
+   let mapping.rhs = 'new_local'
+   call mapset('n', 0, mapping)
+ 
+   " Check that the global mapping is left untouched.
+   let map_list = split(execute('nmap a'), "\n")
+   call assert_match('n\s*a\s*@new_local', map_list[0])
+   call assert_match('n\s*a\s*global', map_list[1])
+ 
+   nunmap a
+ endfunc
+ 
+ func Test_map_restore()
+   " Test restoring map with alternate keycode
+   nmap <C-B> back
+   let d = maparg('<C-B>', 'n', 0, 1)
+   call Check_ctrlb_map(d, 1)
+   let dsimp = maparg("\x02", 'n', 0, 1)
+   call Check_ctrlb_map(dsimp, 0)
+   nunmap <C-B>
+   call mapset('n', 0, d)
+   let d = maparg('<C-B>', 'n', 0, 1)
+   call Check_ctrlb_map(d, 1)
+   let dsimp = maparg("\x02", 'n', 0, 1)
+   call Check_ctrlb_map(dsimp, 0)
+ 
+   nunmap <C-B>
+ 
+ endfunc
+ 
+ def Test_maplist()
+   new
+   def ClearMappingsAbbreviations()
+     mapclear | nmapclear | vmapclear | xmapclear | smapclear | omapclear
+     mapclear!  | imapclear | lmapclear | cmapclear | tmapclear
+     mapclear <buffer> | nmapclear <buffer> | vmapclear <buffer>
+     xmapclear <buffer> | smapclear <buffer> | omapclear <buffer>
+     mapclear! <buffer> | imapclear <buffer> | lmapclear <buffer>
+     cmapclear <buffer> | tmapclear <buffer>
+     abclear | abclear <buffer>
+   enddef
+ 
+   def AddMaps(new: list<string>, accum: list<string>)
+     if len(new) > 0 && new[0] != "No mapping found"
+       accum->extend(new)
+     endif
+   enddef
+ 
+   ClearMappingsAbbreviations()
+   assert_equal(0, len(maplist()))
+   assert_equal(0, len(maplist(true)))
+ 
+   # Set up some mappings.
+   map dup bar
+   map <buffer> dup bufbar
+   map foo<C-V> is<F4>foo
+   vnoremap <script> <buffer> <expr> <silent> bar isbar
+   tmap baz foo
+   omap h w
+   lmap i w
+   nmap j w
+   xmap k w
+   smap l w
+   map abc <Nop>
+   nmap <M-j> x
+   nmap <M-Space> y
+   # And abbreviations
+   abbreviate xy he
+   abbreviate xx she
+   abbreviate <buffer> x they
+ 
+   # Get a list of the mappings with the ':map' commands.
+   # Check maplist() return a list of the same size.
+   assert_equal(13, len(maplist()))
+   assert_equal(3, len(maplist(true)))
+   assert_equal(13, len(maplist(false)))
+ 
+   # collect all the current maps using :map commands
+   var maps_command: list<string>
+   AddMaps(split(execute('map'), '\n'), maps_command)
+   AddMaps(split(execute('map!'), '\n'), maps_command)
+   AddMaps(split(execute('tmap'), '\n'), maps_command)
+   AddMaps(split(execute('lmap'), '\n'), maps_command)
+ 
+   # Use maplist to get all the maps
+   var maps_maplist = maplist()
+   assert_equal(len(maps_command), len(maps_maplist))
+ 
+   # make sure all the mode-lhs are unique, no duplicates
+   var map_set: dict<number>
+   for d in maps_maplist
+     map_set[d.mode .. "-" .. d.lhs .. "-" .. d.buffer] = 0
+   endfor
+   assert_equal(len(maps_maplist), len(map_set))
+ 
+   # For everything returned by maplist, should be the same as from maparg.
+   # Except for "map dup", bacause maparg returns the <buffer> version
+   for d in maps_maplist
+     if d.lhs == 'dup' && d.buffer == 0
+       continue
+     endif
+     var d_maparg = maparg(d.lhs, d.mode, false, true)
+     assert_equal(d_maparg, d)
+   endfor
+ 
+   # Check abbr matches maparg
+   for d in maplist(true)
+     # Note, d.mode is '!', but can't use that with maparg
+     var d_maparg = maparg(d.lhs, 'i', true, true)
+     assert_equal(d_maparg, d)
+   endfor
+ 
+   ClearMappingsAbbreviations()
+   assert_equal(0, len(maplist()))
+   assert_equal(0, len(maplist(true)))
+ enddef
+ 
+ 
+ " vim: shiftwidth=2 sts=2 expandtab
*** ../vim-8.2.4824/src/testdir/Make_all.mak	2022-04-09 13:34:02.780412358 +0100
--- src/testdir/Make_all.mak	2022-04-25 14:22:51.414627999 +0100
***************
*** 184,190 ****
  	test_lua \
  	test_makeencoding \
  	test_man \
! 	test_maparg \
  	test_mapping \
  	test_marks \
  	test_match \
--- 184,190 ----
  	test_lua \
  	test_makeencoding \
  	test_man \
! 	test_map_functions \
  	test_mapping \
  	test_marks \
  	test_match \
***************
*** 425,431 ****
  	test_lua.res \
  	test_makeencoding.res \
  	test_man.res \
! 	test_maparg.res \
  	test_mapping.res \
  	test_marks.res \
  	test_match.res \
--- 425,431 ----
  	test_lua.res \
  	test_makeencoding.res \
  	test_man.res \
! 	test_map_functions.res \
  	test_mapping.res \
  	test_marks.res \
  	test_match.res \
*** ../vim-8.2.4824/src/version.c	2022-04-25 13:27:56.757032651 +0100
--- src/version.c	2022-04-25 14:23:14.018628928 +0100
***************
*** 748,749 ****
--- 748,751 ----
  {   /* Add new patch number below this line */
+ /**/
+     4825,
  /**/

-- 
CVS sux, men don't like commitment

 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
///                                                                      \\\
\\\        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ ///
 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///