--- a/runtime/autoload/ccomplete.vim
+++ b/runtime/autoload/ccomplete.vim
@@ -1,482 +1,523 @@
-" Vim completion script
-" Language:	C
-" Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2020 Nov 14
+vim9script noclear
 
-let s:cpo_save = &cpo
-set cpo&vim
+# Vim completion script
+# Language:     C
+# Maintainer:   Bram Moolenaar <Bram@vim.org>
+#		Rewritten in Vim9 script by github user lacygoill
+# Last Change:  2021 Dec 27
 
-" This function is used for the 'omnifunc' option.
-func ccomplete#Complete(findstart, base)
-  if a:findstart
-    " Locate the start of the item, including ".", "->" and "[...]".
-    let line = getline('.')
-    let start = col('.') - 1
-    let lastword = -1
+var prepended: string
+var grepCache: dict<list<dict<any>>>
+
+# This function is used for the 'omnifunc' option.
+def ccomplete#Complete(findstart: bool, abase: string): any # {{{1
+  if findstart
+    # Locate the start of the item, including ".", "->" and "[...]".
+    var line: string = getline('.')
+    var start: number = charcol('.') - 1
+    var lastword: number = -1
     while start > 0
       if line[start - 1] =~ '\w'
-	let start -= 1
+        --start
       elseif line[start - 1] =~ '\.'
-	if lastword == -1
-	  let lastword = start
-	endif
-	let start -= 1
-      elseif start > 1 && line[start - 2] == '-' && line[start - 1] == '>'
-	if lastword == -1
-	  let lastword = start
-	endif
-	let start -= 2
+        if lastword == -1
+          lastword = start
+        endif
+        --start
+      elseif start > 1 && line[start - 2] == '-'
+        && line[start - 1] == '>'
+        if lastword == -1
+          lastword = start
+        endif
+        start -= 2
       elseif line[start - 1] == ']'
-	" Skip over [...].
-	let n = 0
-	let start -= 1
-	while start > 0
-	  let start -= 1
-	  if line[start] == '['
-	    if n == 0
-	      break
-	    endif
-	    let n -= 1
-	  elseif line[start] == ']'  " nested []
-	    let n += 1
-	  endif
-	endwhile
+        # Skip over [...].
+        var n: number = 0
+        --start
+        while start > 0
+          --start
+          if line[start] == '['
+            if n == 0
+              break
+            endif
+            --n
+          elseif line[start] == ']'  # nested []
+            ++n
+          endif
+        endwhile
       else
-	break
+        break
       endif
     endwhile
 
-    " Return the column of the last word, which is going to be changed.
-    " Remember the text that comes before it in s:prepended.
+    # Return the column of the last word, which is going to be changed.
+    # Remember the text that comes before it in prepended.
     if lastword == -1
-      let s:prepended = ''
-      return start
+      prepended = ''
+      return byteidx(line, start)
     endif
-    let s:prepended = strpart(line, start, lastword - start)
-    return lastword
+    prepended = line[start : lastword - 1]
+    return byteidx(line, lastword)
   endif
 
-  " Return list of matches.
+  # Return list of matches.
 
-  let base = s:prepended . a:base
+  var base: string = prepended .. abase
 
-  " Don't do anything for an empty base, would result in all the tags in the
-  " tags file.
+  # Don't do anything for an empty base, would result in all the tags in the
+  # tags file.
   if base == ''
     return []
   endif
 
-  " init cache for vimgrep to empty
-  let s:grepCache = {}
+  # init cache for vimgrep to empty
+  grepCache = {}
 
-  " Split item in words, keep empty word after "." or "->".
-  " "aa" -> ['aa'], "aa." -> ['aa', ''], "aa.bb" -> ['aa', 'bb'], etc.
-  " We can't use split, because we need to skip nested [...].
-  " "aa[...]" -> ['aa', '[...]'], "aa.bb[...]" -> ['aa', 'bb', '[...]'], etc.
-  let items = []
-  let s = 0
-  let arrays = 0
+  # Split item in words, keep empty word after "." or "->".
+  # "aa" -> ['aa'], "aa." -> ['aa', ''], "aa.bb" -> ['aa', 'bb'], etc.
+  # We can't use split, because we need to skip nested [...].
+  # "aa[...]" -> ['aa', '[...]'], "aa.bb[...]" -> ['aa', 'bb', '[...]'], etc.
+  var items: list<string>
+  var s: number = 0
+  var arrays: number = 0
   while 1
-    let e = match(base, '\.\|->\|\[', s)
+    var e: number = base->charidx(match(base, '\.\|->\|\[', s))
     if e < 0
       if s == 0 || base[s - 1] != ']'
-	call add(items, strpart(base, s))
+        items->add(base[s :])
       endif
       break
     endif
     if s == 0 || base[s - 1] != ']'
-      call add(items, strpart(base, s, e - s))
+      items->add(base[s : e - 1])
     endif
     if base[e] == '.'
-      let s = e + 1	" skip over '.'
+      # skip over '.'
+      s = e + 1
     elseif base[e] == '-'
-      let s = e + 2	" skip over '->'
+      # skip over '->'
+      s = e + 2
     else
-      " Skip over [...].
-      let n = 0
-      let s = e
-      let e += 1
-      while e < len(base)
-	if base[e] == ']'
-	  if n == 0
-	    break
-	  endif
-	  let n -= 1
-	elseif base[e] == '['  " nested [...]
-	  let n += 1
-	endif
-	let e += 1
+      # Skip over [...].
+      var n: number = 0
+      s = e
+      ++e
+      while e < strcharlen(base)
+        if base[e] == ']'
+          if n == 0
+            break
+          endif
+          --n
+        elseif base[e] == '['  # nested [...]
+          ++n
+        endif
+        ++e
       endwhile
-      let e += 1
-      call add(items, strpart(base, s, e - s))
-      let arrays += 1
-      let s = e
+      ++e
+      items->add(base[s : e - 1])
+      ++arrays
+      s = e
     endif
   endwhile
 
-  " Find the variable items[0].
-  " 1. in current function (like with "gd")
-  " 2. in tags file(s) (like with ":tag")
-  " 3. in current file (like with "gD")
-  let res = []
-  if searchdecl(items[0], 0, 1) == 0
-    " Found, now figure out the type.
-    " TODO: join previous line if it makes sense
-    let line = getline('.')
-    let col = col('.')
-    if stridx(strpart(line, 0, col), ';') != -1
-      " Handle multiple declarations on the same line.
-      let col2 = col - 1
+  # Find the variable items[0].
+  # 1. in current function (like with "gd")
+  # 2. in tags file(s) (like with ":tag")
+  # 3. in current file (like with "gD")
+  var res: list<dict<any>>
+  if items[0]->searchdecl(false, true) == 0
+    # Found, now figure out the type.
+    # TODO: join previous line if it makes sense
+    var line: string = getline('.')
+    var col: number = charcol('.')
+    if line[: col - 1]->stridx(';') >= 0
+      # Handle multiple declarations on the same line.
+      var col2: number = col - 1
       while line[col2] != ';'
-	let col2 -= 1
+        --col2
       endwhile
-      let line = strpart(line, col2 + 1)
-      let col -= col2
+      line = line[col2 + 1 :]
+      col -= col2
     endif
-    if stridx(strpart(line, 0, col), ',') != -1
-      " Handle multiple declarations on the same line in a function
-      " declaration.
-      let col2 = col - 1
+    if line[: col - 1]->stridx(',') >= 0
+      # Handle multiple declarations on the same line in a function
+      # declaration.
+      var col2: number = col - 1
       while line[col2] != ','
-	let col2 -= 1
+        --col2
       endwhile
-      if strpart(line, col2 + 1, col - col2 - 1) =~ ' *[^ ][^ ]*  *[^ ]'
-	let line = strpart(line, col2 + 1)
-	let col -= col2
+      if line[col2 + 1 : col - 1] =~ ' *[^ ][^ ]*  *[^ ]'
+        line = line[col2 + 1 :]
+        col -= col2
       endif
     endif
     if len(items) == 1
-      " Completing one word and it's a local variable: May add '[', '.' or
-      " '->'.
-      let match = items[0]
-      let kind = 'v'
-      if match(line, '\<' . match . '\s*\[') > 0
-	let match .= '['
+      # Completing one word and it's a local variable: May add '[', '.' or
+      # '->'.
+      var match: string = items[0]
+      var kind: string = 'v'
+      if match(line, '\<' .. match .. '\s*\[') > 0
+        match ..= '['
       else
-	let res = s:Nextitem(strpart(line, 0, col), [''], 0, 1)
-	if len(res) > 0
-	  " There are members, thus add "." or "->".
-	  if match(line, '\*[ \t(]*' . match . '\>') > 0
-	    let match .= '->'
-	  else
-	    let match .= '.'
-	  endif
-	endif
+        res = line[: col - 1]->Nextitem([''], 0, true)
+        if len(res) > 0
+          # There are members, thus add "." or "->".
+          if match(line, '\*[ \t(]*' .. match .. '\>') > 0
+            match ..= '->'
+          else
+            match ..= '.'
+          endif
+        endif
       endif
-      let res = [{'match': match, 'tagline' : '', 'kind' : kind, 'info' : line}]
+      res = [{match: match, tagline: '', kind: kind, info: line}]
     elseif len(items) == arrays + 1
-      " Completing one word and it's a local array variable: build tagline
-      " from declaration line
-      let match = items[0]
-      let kind = 'v'
-      let tagline = "\t/^" . line . '$/'
-      let res = [{'match': match, 'tagline' : tagline, 'kind' : kind, 'info' : line}]
+      # Completing one word and it's a local array variable: build tagline
+      # from declaration line
+      var match: string = items[0]
+      var kind: string = 'v'
+      var tagline: string = "\t/^" .. line .. '$/'
+      res = [{match: match, tagline: tagline, kind: kind, info: line}]
     else
-      " Completing "var.", "var.something", etc.
-      let res = s:Nextitem(strpart(line, 0, col), items[1:], 0, 1)
+      # Completing "var.", "var.something", etc.
+      res = line[: col - 1]->Nextitem(items[1 :], 0, true)
     endif
   endif
 
   if len(items) == 1 || len(items) == arrays + 1
-    " Only one part, no "." or "->": complete from tags file.
+    # Only one part, no "." or "->": complete from tags file.
+    var tags: list<dict<any>>
     if len(items) == 1
-      let tags = taglist('^' . base)
+      tags = taglist('^' .. base)
     else
-      let tags = taglist('^' . items[0] . '$')
+      tags = taglist('^' .. items[0] .. '$')
     endif
 
-    " Remove members, these can't appear without something in front.
-    call filter(tags, 'has_key(v:val, "kind") ? v:val["kind"] != "m" : 1')
+    tags
+      # Remove members, these can't appear without something in front.
+      ->filter((_, v: dict<any>): bool =>
+                v->has_key('kind') ? v.kind != 'm' : true)
+      # Remove static matches in other files.
+      ->filter((_, v: dict<any>): bool =>
+                 !v->has_key('static')
+              || !v['static']
+              || bufnr('%') == bufnr(v['filename']))
 
-    " Remove static matches in other files.
-    call filter(tags, '!has_key(v:val, "static") || !v:val["static"] || bufnr("%") == bufnr(v:val["filename"])')
-
-    call extend(res, map(tags, 's:Tag2item(v:val)'))
+    res = extendnew(res, tags->map((_, v: dict<any>) => Tag2item(v)))
   endif
 
   if len(res) == 0
-    " Find the variable in the tags file(s)
-    let diclist = taglist('^' . items[0] . '$')
-
-    " Remove members, these can't appear without something in front.
-    call filter(diclist, 'has_key(v:val, "kind") ? v:val["kind"] != "m" : 1')
+    # Find the variable in the tags file(s)
+    var diclist: list<dict<any>> = taglist('^' .. items[0] .. '$')
+      # Remove members, these can't appear without something in front.
+      ->filter((_, v: dict<string>): bool =>
+                v->has_key('kind') ? v.kind != 'm' : true)
 
-    let res = []
-    for i in range(len(diclist))
-      " New ctags has the "typeref" field.  Patched version has "typename".
-      if has_key(diclist[i], 'typename')
-	call extend(res, s:StructMembers(diclist[i]['typename'], items[1:], 1))
-      elseif has_key(diclist[i], 'typeref')
-	call extend(res, s:StructMembers(diclist[i]['typeref'], items[1:], 1))
+    res = []
+    for i: number in len(diclist)->range()
+      # New ctags has the "typeref" field.  Patched version has "typename".
+      if diclist[i]->has_key('typename')
+        res = extendnew(res, diclist[i]['typename']->StructMembers(items[1 :], true))
+      elseif diclist[i]->has_key('typeref')
+        res = extendnew(res, diclist[i]['typeref']->StructMembers(items[1 :], true))
       endif
 
-      " For a variable use the command, which must be a search pattern that
-      " shows the declaration of the variable.
+      # For a variable use the command, which must be a search pattern that
+      # shows the declaration of the variable.
       if diclist[i]['kind'] == 'v'
-	let line = diclist[i]['cmd']
-	if line[0] == '/' && line[1] == '^'
-	  let col = match(line, '\<' . items[0] . '\>')
-	  call extend(res, s:Nextitem(strpart(line, 2, col - 2), items[1:], 0, 1))
-	endif
+        var line: string = diclist[i]['cmd']
+        if line[: 1] == '/^'
+          var col: number = line->charidx(match(line, '\<' .. items[0] .. '\>'))
+          res = extendnew(res, line[2 : col - 1]->Nextitem(items[1 :], 0, true))
+        endif
       endif
     endfor
   endif
 
-  if len(res) == 0 && searchdecl(items[0], 1) == 0
-    " Found, now figure out the type.
-    " TODO: join previous line if it makes sense
-    let line = getline('.')
-    let col = col('.')
-    let res = s:Nextitem(strpart(line, 0, col), items[1:], 0, 1)
+  if len(res) == 0 && items[0]->searchdecl(true) == 0
+    # Found, now figure out the type.
+    # TODO: join previous line if it makes sense
+    var line: string = getline('.')
+    var col: number = charcol('.')
+    res = line[: col - 1]->Nextitem(items[1 :], 0, true)
   endif
 
-  " If the last item(s) are [...] they need to be added to the matches.
-  let last = len(items) - 1
-  let brackets = ''
+  # If the last item(s) are [...] they need to be added to the matches.
+  var last: number = len(items) - 1
+  var brackets: string = ''
   while last >= 0
     if items[last][0] != '['
       break
     endif
-    let brackets = items[last] . brackets
-    let last -= 1
+    brackets = items[last] .. brackets
+    --last
   endwhile
 
-  return map(res, 's:Tagline2item(v:val, brackets)')
-endfunc
+  return res->map((_, v: dict<any>): dict<string> => Tagline2item(v, brackets))
+enddef
 
-func s:GetAddition(line, match, memarg, bracket)
-  " Guess if the item is an array.
-  if a:bracket && match(a:line, a:match . '\s*\[') > 0
+def GetAddition( # {{{1
+  line: string,
+  match: string,
+  memarg: list<dict<any>>,
+  bracket: bool
+): string
+  # Guess if the item is an array.
+  if bracket && match(line, match .. '\s*\[') > 0
     return '['
   endif
 
-  " Check if the item has members.
-  if len(s:SearchMembers(a:memarg, [''], 0)) > 0
-    " If there is a '*' before the name use "->".
-    if match(a:line, '\*[ \t(]*' . a:match . '\>') > 0
+  # Check if the item has members.
+  if SearchMembers(memarg, [''], false)->len() > 0
+    # If there is a '*' before the name use "->".
+    if match(line, '\*[ \t(]*' .. match .. '\>') > 0
       return '->'
     else
       return '.'
     endif
   endif
   return ''
-endfunc
+enddef
 
-" Turn the tag info "val" into an item for completion.
-" "val" is is an item in the list returned by taglist().
-" If it is a variable we may add "." or "->".  Don't do it for other types,
-" such as a typedef, by not including the info that s:GetAddition() uses.
-func s:Tag2item(val)
-  let res = {'match': a:val['name']}
+def Tag2item(val: dict<any>): dict<any> # {{{1
+# Turn the tag info "val" into an item for completion.
+# "val" is is an item in the list returned by taglist().
+# If it is a variable we may add "." or "->".  Don't do it for other types,
+# such as a typedef, by not including the info that GetAddition() uses.
+  var res: dict<any> = {match: val['name']}
 
-  let res['extra'] = s:Tagcmd2extra(a:val['cmd'], a:val['name'], a:val['filename'])
+  res['extra'] = Tagcmd2extra(val['cmd'], val['name'], val['filename'])
 
-  let s = s:Dict2info(a:val)
+  var s: string = Dict2info(val)
   if s != ''
-    let res['info'] = s
+    res['info'] = s
   endif
 
-  let res['tagline'] = ''
-  if has_key(a:val, "kind")
-    let kind = a:val['kind']
-    let res['kind'] = kind
+  res['tagline'] = ''
+  if val->has_key('kind')
+    var kind: string = val['kind']
+    res['kind'] = kind
     if kind == 'v'
-      let res['tagline'] = "\t" . a:val['cmd']
-      let res['dict'] = a:val
+      res['tagline'] = "\t" .. val['cmd']
+      res['dict'] = val
     elseif kind == 'f'
-      let res['match'] = a:val['name'] . '('
+      res['match'] = val['name'] .. '('
     endif
   endif
 
   return res
-endfunc
+enddef
 
-" Use all the items in dictionary for the "info" entry.
-func s:Dict2info(dict)
-  let info = ''
-  for k in sort(keys(a:dict))
-    let info  .= k . repeat(' ', 10 - len(k))
+def Dict2info(dict: dict<any>): string # {{{1
+# Use all the items in dictionary for the "info" entry.
+  var info: string = ''
+  for k: string in dict->keys()->sort()
+    info  ..= k .. repeat(' ', 10 - strlen(k))
     if k == 'cmd'
-      let info .= substitute(matchstr(a:dict['cmd'], '/^\s*\zs.*\ze$/'), '\\\(.\)', '\1', 'g')
+      info ..= dict['cmd']
+        ->matchstr('/^\s*\zs.*\ze$/')
+        ->substitute('\\\(.\)', '\1', 'g')
     else
-      let info .= a:dict[k]
+      var dictk: any = dict[k]
+      if typename(dictk) != 'string'
+        info ..= dictk->string()
+      else
+        info ..= dictk
+      endif
     endif
-    let info .= "\n"
+    info ..= "\n"
   endfor
   return info
-endfunc
+enddef
 
-" Parse a tag line and return a dictionary with items like taglist()
-func s:ParseTagline(line)
-  let l = split(a:line, "\t")
-  let d = {}
+def ParseTagline(line: string): dict<any> # {{{1
+# Parse a tag line and return a dictionary with items like taglist()
+  var l: list<string> = split(line, "\t")
+  var d: dict<any>
   if len(l) >= 3
-    let d['name'] = l[0]
-    let d['filename'] = l[1]
-    let d['cmd'] = l[2]
-    let n = 2
+    d['name'] = l[0]
+    d['filename'] = l[1]
+    d['cmd'] = l[2]
+    var n: number = 2
     if l[2] =~ '^/'
-      " Find end of cmd, it may contain Tabs.
+      # Find end of cmd, it may contain Tabs.
       while n < len(l) && l[n] !~ '/;"$'
-	let n += 1
-	let d['cmd'] .= "  " . l[n]
+        ++n
+        d['cmd'] ..= '  ' .. l[n]
       endwhile
     endif
-    for i in range(n + 1, len(l) - 1)
+    for i: number in range(n + 1, len(l) - 1)
       if l[i] == 'file:'
-	let d['static'] = 1
+        d['static'] = 1
       elseif l[i] !~ ':'
-	let d['kind'] = l[i]
+        d['kind'] = l[i]
       else
-	let d[matchstr(l[i], '[^:]*')] = matchstr(l[i], ':\zs.*')
+        d[l[i]->matchstr('[^:]*')] = l[i]->matchstr(':\zs.*')
       endif
     endfor
   endif
 
   return d
-endfunc
+enddef
 
-" Turn a match item "val" into an item for completion.
-" "val['match']" is the matching item.
-" "val['tagline']" is the tagline in which the last part was found.
-func s:Tagline2item(val, brackets)
-  let line = a:val['tagline']
-  let add = s:GetAddition(line, a:val['match'], [a:val], a:brackets == '')
-  let res = {'word': a:val['match'] . a:brackets . add }
+def Tagline2item(val: dict<any>, brackets: string): dict<string> # {{{1
+# Turn a match item "val" into an item for completion.
+# "val['match']" is the matching item.
+# "val['tagline']" is the tagline in which the last part was found.
+  var line: string = val['tagline']
+  var add: string = GetAddition(line, val['match'], [val], brackets == '')
+  var res: dict<string> = {word: val['match'] .. brackets .. add}
 
-  if has_key(a:val, 'info')
-    " Use info from Tag2item().
-    let res['info'] = a:val['info']
+  if val->has_key('info')
+    # Use info from Tag2item().
+    res['info'] = val['info']
   else
-    " Parse the tag line and add each part to the "info" entry.
-    let s = s:Dict2info(s:ParseTagline(line))
+    # Parse the tag line and add each part to the "info" entry.
+    var s: string = ParseTagline(line)->Dict2info()
     if s != ''
-      let res['info'] = s
+      res['info'] = s
     endif
   endif
 
-  if has_key(a:val, 'kind')
-    let res['kind'] = a:val['kind']
+  if val->has_key('kind')
+    res['kind'] = val['kind']
   elseif add == '('
-    let res['kind'] = 'f'
+    res['kind'] = 'f'
   else
-    let s = matchstr(line, '\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
+    var s: string = line->matchstr('\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
     if s != ''
-      let res['kind'] = s
+      res['kind'] = s
     endif
   endif
 
-  if has_key(a:val, 'extra')
-    let res['menu'] = a:val['extra']
+  if val->has_key('extra')
+    res['menu'] = val['extra']
     return res
   endif
 
-  " Isolate the command after the tag and filename.
-  let s = matchstr(line, '[^\t]*\t[^\t]*\t\zs\(/^.*$/\|[^\t]*\)\ze\(;"\t\|\t\|$\)')
+  # Isolate the command after the tag and filename.
+  var s: string = line->matchstr('[^\t]*\t[^\t]*\t\zs\(/^.*$/\|[^\t]*\)\ze\(;"\t\|\t\|$\)')
   if s != ''
-    let res['menu'] = s:Tagcmd2extra(s, a:val['match'], matchstr(line, '[^\t]*\t\zs[^\t]*\ze\t'))
+    res['menu'] = s->Tagcmd2extra(val['match'], line->matchstr('[^\t]*\t\zs[^\t]*\ze\t'))
   endif
   return res
-endfunc
+enddef
 
-" Turn a command from a tag line to something that is useful in the menu
-func s:Tagcmd2extra(cmd, name, fname)
-  if a:cmd =~ '^/^'
-    " The command is a search command, useful to see what it is.
-    let x = matchstr(a:cmd, '^/^\s*\zs.*\ze$/')
-    let x = substitute(x, '\<' . a:name . '\>', '@@', '')
-    let x = substitute(x, '\\\(.\)', '\1', 'g')
-    let x = x . ' - ' . a:fname
-  elseif a:cmd =~ '^\d*$'
-    " The command is a line number, the file name is more useful.
-    let x = a:fname . ' - ' . a:cmd
+def Tagcmd2extra( # {{{1
+  cmd: string,
+  name: string,
+  fname: string
+): string
+# Turn a command from a tag line to something that is useful in the menu
+  var x: string
+  if cmd =~ '^/^'
+    # The command is a search command, useful to see what it is.
+    x = cmd
+      ->matchstr('^/^\s*\zs.*\ze$/')
+      ->substitute('\<' .. name .. '\>', '@@', '')
+      ->substitute('\\\(.\)', '\1', 'g')
+      .. ' - ' .. fname
+  elseif cmd =~ '^\d*$'
+    # The command is a line number, the file name is more useful.
+    x = fname .. ' - ' .. cmd
   else
-    " Not recognized, use command and file name.
-    let x = a:cmd . ' - ' . a:fname
+    # Not recognized, use command and file name.
+    x = cmd .. ' - ' .. fname
   endif
   return x
-endfunc
-
-" Find composing type in "lead" and match items[0] with it.
-" Repeat this recursively for items[1], if it's there.
-" When resolving typedefs "depth" is used to avoid infinite recursion.
-" Return the list of matches.
-func s:Nextitem(lead, items, depth, all)
+enddef
 
-  " Use the text up to the variable name and split it in tokens.
-  let tokens = split(a:lead, '\s\+\|\<')
+def Nextitem( # {{{1
+  lead: string,
+  items: list<string>,
+  depth: number,
+  all: bool
+): list<dict<string>>
+# Find composing type in "lead" and match items[0] with it.
+# Repeat this recursively for items[1], if it's there.
+# When resolving typedefs "depth" is used to avoid infinite recursion.
+# Return the list of matches.
 
-  " Try to recognize the type of the variable.  This is rough guessing...
-  let res = []
-  for tidx in range(len(tokens))
+  # Use the text up to the variable name and split it in tokens.
+  var tokens: list<string> = split(lead, '\s\+\|\<')
 
-    " Skip tokens starting with a non-ID character.
+  # Try to recognize the type of the variable.  This is rough guessing...
+  var res: list<dict<string>>
+  for tidx: number in len(tokens)->range()
+
+    # Skip tokens starting with a non-ID character.
     if tokens[tidx] !~ '^\h'
       continue
     endif
 
-    " Recognize "struct foobar" and "union foobar".
-    " Also do "class foobar" when it's C++ after all (doesn't work very well
-    " though).
-    if (tokens[tidx] == 'struct' || tokens[tidx] == 'union' || tokens[tidx] == 'class') && tidx + 1 < len(tokens)
-      let res = s:StructMembers(tokens[tidx] . ':' . tokens[tidx + 1], a:items, a:all)
+    # Recognize "struct foobar" and "union foobar".
+    # Also do "class foobar" when it's C++ after all (doesn't work very well
+    # though).
+    if (tokens[tidx] == 'struct'
+      || tokens[tidx] == 'union'
+      || tokens[tidx] == 'class')
+      && tidx + 1 < len(tokens)
+      res = StructMembers(tokens[tidx] .. ':' .. tokens[tidx + 1], items, all)
       break
     endif
 
-    " TODO: add more reserved words
-    if index(['int', 'short', 'char', 'float', 'double', 'static', 'unsigned', 'extern'], tokens[tidx]) >= 0
+    # TODO: add more reserved words
+    if ['int', 'short', 'char', 'float',
+        'double', 'static', 'unsigned', 'extern']->index(tokens[tidx]) >= 0
       continue
     endif
 
-    " Use the tags file to find out if this is a typedef.
-    let diclist = taglist('^' . tokens[tidx] . '$')
-    for tagidx in range(len(diclist))
-      let item = diclist[tagidx]
+    # Use the tags file to find out if this is a typedef.
+    var diclist: list<dict<any>> = taglist('^' .. tokens[tidx] .. '$')
+    for tagidx: number in len(diclist)->range()
+      var item: dict<any> = diclist[tagidx]
 
-      " New ctags has the "typeref" field.  Patched version has "typename".
-      if has_key(item, 'typeref')
-	call extend(res, s:StructMembers(item['typeref'], a:items, a:all))
-	continue
+      # New ctags has the "typeref" field.  Patched version has "typename".
+      if item->has_key('typeref')
+        res = extendnew(res, item['typeref']->StructMembers(items, all))
+        continue
       endif
-      if has_key(item, 'typename')
-	call extend(res, s:StructMembers(item['typename'], a:items, a:all))
-	continue
+      if item->has_key('typename')
+        res = extendnew(res, item['typename']->StructMembers(items, all))
+        continue
       endif
 
-      " Only handle typedefs here.
+      # Only handle typedefs here.
       if item['kind'] != 't'
-	continue
+        continue
       endif
 
-      " Skip matches local to another file.
-      if has_key(item, 'static') && item['static'] && bufnr('%') != bufnr(item['filename'])
-	continue
+      # Skip matches local to another file.
+      if item->has_key('static') && item['static']
+        && bufnr('%') != bufnr(item['filename'])
+        continue
       endif
 
-      " For old ctags we recognize "typedef struct aaa" and
-      " "typedef union bbb" in the tags file command.
-      let cmd = item['cmd']
-      let ei = matchend(cmd, 'typedef\s\+')
+      # For old ctags we recognize "typedef struct aaa" and
+      # "typedef union bbb" in the tags file command.
+      var cmd: string = item['cmd']
+      var ei: number = cmd->charidx(matchend(cmd, 'typedef\s\+'))
       if ei > 1
-	let cmdtokens = split(strpart(cmd, ei), '\s\+\|\<')
-	if len(cmdtokens) > 1
-	  if cmdtokens[0] == 'struct' || cmdtokens[0] == 'union' || cmdtokens[0] == 'class'
-	    let name = ''
-	    " Use the first identifier after the "struct" or "union"
-	    for ti in range(len(cmdtokens) - 1)
-	      if cmdtokens[ti] =~ '^\w'
-		let name = cmdtokens[ti]
-		break
-	      endif
-	    endfor
-	    if name != ''
-	      call extend(res, s:StructMembers(cmdtokens[0] . ':' . name, a:items, a:all))
-	    endif
-	  elseif a:depth < 10
-	    " Could be "typedef other_T some_T".
-	    call extend(res, s:Nextitem(cmdtokens[0], a:items, a:depth + 1, a:all))
-	  endif
-	endif
+        var cmdtokens: list<string> = cmd[ei :]->split('\s\+\|\<')
+        if len(cmdtokens) > 1
+          if cmdtokens[0] == 'struct'
+            || cmdtokens[0] == 'union'
+            || cmdtokens[0] == 'class'
+            var name: string = ''
+            # Use the first identifier after the "struct" or "union"
+            for ti: number in (len(cmdtokens) - 1)->range()
+              if cmdtokens[ti] =~ '^\w'
+                name = cmdtokens[ti]
+                break
+              endif
+            endfor
+            if name != ''
+              res = extendnew(res, StructMembers(cmdtokens[0] .. ':' .. name, items, all))
+            endif
+          elseif depth < 10
+            # Could be "typedef other_T some_T".
+            res = extendnew(res, cmdtokens[0]->Nextitem(items, depth + 1, all))
+          endif
+        endif
       endif
     endfor
     if len(res) > 0
@@ -485,155 +526,173 @@ func s:Nextitem(lead, items, depth, all)
   endfor
 
   return res
-endfunc
+enddef
 
+def StructMembers( # {{{1
+  atypename: string,
+  items: list<string>,
+  all: bool
+): list<dict<string>>
 
-" Search for members of structure "typename" in tags files.
-" Return a list with resulting matches.
-" Each match is a dictionary with "match" and "tagline" entries.
-" When "all" is non-zero find all, otherwise just return 1 if there is any
-" member.
-func s:StructMembers(typename, items, all)
-  " Todo: What about local structures?
-  let fnames = join(map(tagfiles(), 'escape(v:val, " \\#%")'))
+# Search for members of structure "typename" in tags files.
+# Return a list with resulting matches.
+# Each match is a dictionary with "match" and "tagline" entries.
+# When "all" is true find all, otherwise just return 1 if there is any member.
+
+  # Todo: What about local structures?
+  var fnames: string = tagfiles()
+    ->map((_, v: string) => escape(v, ' \#%'))
+    ->join()
   if fnames == ''
     return []
   endif
 
-  let typename = a:typename
-  let qflist = []
-  let cached = 0
-  if a:all == 0
-    let n = '1'	" stop at first found match
-    if has_key(s:grepCache, a:typename)
-      let qflist = s:grepCache[a:typename]
-      let cached = 1
+  var typename: string = atypename
+  var qflist: list<dict<any>>
+  var cached: number = 0
+  var n: string
+  if !all
+    n = '1'  # stop at first found match
+    if grepCache->has_key(typename)
+      qflist = grepCache[typename]
+      cached = 1
     endif
   else
-    let n = ''
+    n = ''
   endif
   if !cached
     while 1
-      exe 'silent! keepj noautocmd ' . n . 'vimgrep /\t' . typename . '\(\t\|$\)/j ' . fnames
+      execute 'silent! keepjumps noautocmd '
+        .. n .. 'vimgrep ' .. '/\t' .. typename .. '\(\t\|$\)/j '
+        .. fnames
 
-      let qflist = getqflist()
-      if len(qflist) > 0 || match(typename, "::") < 0
-	break
+      qflist = getqflist()
+      if len(qflist) > 0 || match(typename, '::') < 0
+        break
       endif
-      " No match for "struct:context::name", remove "context::" and try again.
-      let typename = substitute(typename, ':[^:]*::', ':', '')
+      # No match for "struct:context::name", remove "context::" and try again.
+      typename = typename->substitute(':[^:]*::', ':', '')
     endwhile
 
-    if a:all == 0
-      " Store the result to be able to use it again later.
-      let s:grepCache[a:typename] = qflist
+    if !all
+      # Store the result to be able to use it again later.
+      grepCache[typename] = qflist
     endif
   endif
 
-  " Skip over [...] items
-  let idx = 0
+  # Skip over [...] items
+  var idx: number = 0
+  var target: string
   while 1
-    if idx >= len(a:items)
-      let target = ''		" No further items, matching all members
+    if idx >= len(items)
+      target = ''  # No further items, matching all members
       break
     endif
-    if a:items[idx][0] != '['
-      let target = a:items[idx]
+    if items[idx][0] != '['
+      target = items[idx]
       break
     endif
-    let idx += 1
+    ++idx
   endwhile
-  " Put matching members in matches[].
-  let matches = []
-  for l in qflist
-    let memb = matchstr(l['text'], '[^\t]*')
-    if memb =~ '^' . target
-      " Skip matches local to another file.
-      if match(l['text'], "\tfile:") < 0 || bufnr('%') == bufnr(matchstr(l['text'], '\t\zs[^\t]*'))
-	let item = {'match': memb, 'tagline': l['text']}
+  # Put matching members in matches[].
+  var matches: list<dict<string>>
+  for l: dict<any> in qflist
+    var memb: string = l['text']->matchstr('[^\t]*')
+    if memb =~ '^' .. target
+      # Skip matches local to another file.
+      if match(l['text'], "\tfile:") < 0
+        || bufnr('%') == l['text']->matchstr('\t\zs[^\t]*')->bufnr()
+        var item: dict<string> = {match: memb, tagline: l['text']}
 
-	" Add the kind of item.
-	let s = matchstr(l['text'], '\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
-	if s != ''
-	  let item['kind'] = s
-	  if s == 'f'
-	    let item['match'] = memb . '('
-	  endif
-	endif
+        # Add the kind of item.
+        var s: string = l['text']->matchstr('\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
+        if s != ''
+          item['kind'] = s
+          if s == 'f'
+            item['match'] = memb .. '('
+          endif
+        endif
 
-	call add(matches, item)
+        matches->add(item)
       endif
     endif
   endfor
 
   if len(matches) > 0
-    " Skip over next [...] items
-    let idx += 1
+    # Skip over next [...] items
+    ++idx
     while 1
-      if idx >= len(a:items)
-	return matches		" No further items, return the result.
+      if idx >= len(items)
+        return matches  # No further items, return the result.
       endif
-      if a:items[idx][0] != '['
-	break
+      if items[idx][0] != '['
+        break
       endif
-      let idx += 1
+      ++idx
     endwhile
 
-    " More items following.  For each of the possible members find the
-    " matching following members.
-    return s:SearchMembers(matches, a:items[idx :], a:all)
+    # More items following.  For each of the possible members find the
+    # matching following members.
+    return SearchMembers(matches, items[idx :], all)
   endif
 
-  " Failed to find anything.
+  # Failed to find anything.
   return []
-endfunc
+enddef
+
+def SearchMembers( # {{{1
+  matches: list<dict<any>>,
+  items: list<string>,
+  all: bool
+): list<dict<string>>
 
-" For matching members, find matches for following items.
-" When "all" is non-zero find all, otherwise just return 1 if there is any
-" member.
-func s:SearchMembers(matches, items, all)
-  let res = []
-  for i in range(len(a:matches))
-    let typename = ''
-    if has_key(a:matches[i], 'dict')
-      if has_key(a:matches[i].dict, 'typename')
-	let typename = a:matches[i].dict['typename']
-      elseif has_key(a:matches[i].dict, 'typeref')
-	let typename = a:matches[i].dict['typeref']
+# For matching members, find matches for following items.
+# When "all" is true find all, otherwise just return 1 if there is any member.
+  var res: list<dict<string>>
+  for i: number in len(matches)->range()
+    var typename: string = ''
+    var line: string
+    if matches[i]->has_key('dict')
+      if matches[i]['dict']->has_key('typename')
+        typename = matches[i]['dict']['typename']
+      elseif matches[i]['dict']->has_key('typeref')
+        typename = matches[i]['dict']['typeref']
       endif
-      let line = "\t" . a:matches[i].dict['cmd']
+      line = "\t" .. matches[i]['dict']['cmd']
     else
-      let line = a:matches[i]['tagline']
-      let e = matchend(line, '\ttypename:')
+      line = matches[i]['tagline']
+      var eb: number = matchend(line, '\ttypename:')
+      var e: number = charidx(line, eb)
       if e < 0
-	let e = matchend(line, '\ttyperef:')
+        eb = matchend(line, '\ttyperef:')
+        e = charidx(line, eb)
       endif
       if e > 0
-	" Use typename field
-	let typename = matchstr(line, '[^\t]*', e)
+        # Use typename field
+        typename = line->matchstr('[^\t]*', eb)
       endif
     endif
 
     if typename != ''
-      call extend(res, s:StructMembers(typename, a:items, a:all))
+      res = extendnew(res, StructMembers(typename, items, all))
     else
-      " Use the search command (the declaration itself).
-      let s = match(line, '\t\zs/^')
+      # Use the search command (the declaration itself).
+      var sb: number = line->match('\t\zs/^')
+      var s: number = charidx(line, sb)
       if s > 0
-	let e = match(line, '\<' . a:matches[i]['match'] . '\>', s)
-	if e > 0
-	  call extend(res, s:Nextitem(strpart(line, s, e - s), a:items, 0, a:all))
-	endif
+        var e: number = line
+          ->charidx(match(line, '\<' .. matches[i]['match'] .. '\>', sb))
+        if e > 0
+          res = extendnew(res, line[s : e - 1]->Nextitem(items, 0, all))
+        endif
       endif
     endif
-    if a:all == 0 && len(res) > 0
+    if !all && len(res) > 0
       break
     endif
   endfor
   return res
-endfunc
+enddef
+#}}}1
 
-let &cpo = s:cpo_save
-unlet s:cpo_save
-
-" vim: noet sw=2 sts=2
+# vim: noet sw=2 sts=2