plugins update

sources_non_forked/vim-go/autoload/go/package.vim

@@ -32,7 +32,7 @@ if len(s:goarch) == 0
   endif
 endif
 
-function! go#package#Paths() abort
+function! s:paths() abort
   let dirs = []
 
   if !exists("s:goroot")
@@ -58,6 +58,58 @@ function! go#package#Paths() abort
   return dirs
 endfunction
 
+function! s:module() abort
+  let [l:out, l:err] = go#util#ExecInDir(['go', 'list', '-m', '-f', '{{.Dir}}'])
+  if l:err != 0
+    return {}
+  endif
+  let l:dir = split(l:out, '\n')[0]
+
+  let [l:out, l:err] = go#util#ExecInDir(['go', 'list', '-m', '-f', '{{.Path}}'])
+  if l:err != 0
+    return {}
+  endif
+  let l:path = split(l:out, '\n')[0]
+
+  return {'dir': l:dir, 'path': l:path}
+endfunction
+
+function! s:vendordirs() abort
+  let l:vendorsuffix = go#util#PathSep() . 'vendor'
+  let l:module = s:module()
+  if empty(l:module)
+    let [l:root, l:err] = go#util#ExecInDir(['go', 'list', '-f', '{{.Root}}'])
+    if l:err != 0
+      return []
+    endif
+    let l:root = split(l:root, '\n')[0] . go#util#PathSep() . 'src'
+
+    let [l:dir, l:err] = go#util#ExecInDir(['go', 'list', '-f', '{{.Dir}}'])
+    if l:err != 0
+      return []
+    endif
+    let l:dir = split(l:dir, '\n')[0]
+
+    let l:vendordirs = []
+    while l:dir != l:root
+      let l:vendordir = l:dir . l:vendorsuffix
+      if isdirectory(l:vendordir)
+        let l:vendordirs = add(l:vendordirs, l:vendordir)
+      endif
+
+      let l:dir = fnamemodify(l:dir, ':h')
+    endwhile
+
+    return l:vendordirs
+  endif
+
+  let l:vendordir = l:module.dir . l:vendorsuffix
+  if !isdirectory(l:vendordir)
+    return []
+  endif
+  return [l:vendordir]
+endfunction
+
 let s:import_paths = {}
 " ImportPath returns the import path of the package for current buffer.
 function! go#package#ImportPath() abort
@@ -85,7 +137,9 @@ function! go#package#ImportPath() abort
 endfunction
 
 
-" FromPath returns the import path of arg.
+" go#package#FromPath returns the import path of arg. -1 is returned when arg
+" does not specify a package. -2 is returned when arg is a relative path
+" outside of GOPATH and not in a module.
 function! go#package#FromPath(arg) abort
   let l:cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
   let l:dir = getcwd()
@@ -104,10 +158,10 @@ function! go#package#FromPath(arg) abort
 
   let l:importpath = split(l:out, '\n')[0]
 
-  " go list returns '_CURRENTDIRECTORY' if the directory is not inside GOPATH.
-  " Check it and retun an error if that is the case
+  " go list returns '_CURRENTDIRECTORY' if the directory is neither in GOPATH
+  " nor in a module. Check it and retun an error if that is the case
   if l:importpath[0] ==# '_'
-    return -1
+    return -2
   endif
 
   return l:importpath
@@ -144,33 +198,80 @@ function! go#package#Complete(ArgLead, CmdLine, CursorPos) abort
     return go#package#CompleteMembers(words[1], words[2])
   endif
 
-  let dirs = go#package#Paths()
+  let dirs = s:paths()
+  let module = s:module()
 
-  if len(dirs) == 0
+  if len(dirs) == 0 && empty(module)
     " should not happen
     return []
   endif
 
+  let vendordirs = s:vendordirs()
+
   let ret = {}
   for dir in dirs
     " this may expand to multiple lines
     let root = split(expand(dir . '/pkg/' . s:goos . '_' . s:goarch), "\n")
-    call add(root, expand(dir . '/src'))
-    for r in root
-      for i in split(globpath(r, a:ArgLead.'*'), "\n")
-        if isdirectory(i)
-          let i .= '/'
-        elseif i !~ '\.a$'
+    let root = add(root, expand(dir . '/src'), )
+    let root = extend(root, vendordirs)
+    let root = add(root, module)
+    for item in root
+      " item may be a dictionary when operating in a module.
+      if type(item) == type({})
+        if empty(item)
           continue
         endif
-        let i = substitute(substitute(i[len(r)+1:], '[\\]', '/', 'g'),
+        let dir = item.dir
+        let path = item.path
+      else
+        let dir = item
+        let path = item
+      endif
+
+      if !empty(module) && dir ==# module.dir
+        if stridx(a:ArgLead, module.path) == 0
+          if len(a:ArgLead) != len(module.path)
+            let glob = globpath(module.dir, substitute(a:ArgLead, module.path . '/\?', '', '').'*')
+          else
+            let glob = module.dir
+          endif
+        elseif stridx(module.path, a:ArgLead) == 0 && stridx(module.path, '/', len(a:ArgLead)) < 0
+          " use the module directory when a:ArgLead is contained in
+          " module.path and module.path does not have any path segments after
+          " a:ArgLead.
+          let glob = module.dir
+        else
+          continue
+        endif
+      else
+        let glob = globpath(dir, a:ArgLead.'*')
+      endif
+      for candidate in split(glob)
+        if isdirectory(candidate)
+          " TODO(bc): use wildignore instead of filtering out vendor
+          " directories manually?
+          if fnamemodify(candidate, ':t') == 'vendor'
+            continue
+          endif
+          let candidate .= '/'
+        elseif candidate !~ '\.a$'
+          continue
+        endif
+
+        if dir !=# path
+          let candidate = substitute(candidate, '^' . dir, path, 'g')
+        else
+          let candidate = candidate[len(dir)+1:]
+        endif
+        " replace a backslash with a forward slash and drop .a suffixes
+        let candidate = substitute(substitute(candidate, '[\\]', '/', 'g'),
                           \ '\.a$', '', 'g')
 
         " without this the result can have duplicates in form of
         " 'encoding/json' and '/encoding/json/'
-        let i = go#util#StripPathSep(i)
+        let candidate = go#util#StripPathSep(candidate)
 
-        let ret[i] = i
+        let ret[candidate] = candidate
       endfor
     endfor
   endfor