.gitignore added

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.1.0 / go / loader / util.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/go/loader/util.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/go/loader/util.go
new file mode 100644 (file)
index 0000000..7f38dd7
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/go/loader/util.go
@@ -0,0 +1,124 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package loader
+
+import (
+       "go/ast"
+       "go/build"
+       "go/parser"
+       "go/token"
+       "io"
+       "os"
+       "strconv"
+       "sync"
+
+       "golang.org/x/tools/go/buildutil"
+)
+
+// We use a counting semaphore to limit
+// the number of parallel I/O calls per process.
+var ioLimit = make(chan bool, 10)
+
+// parseFiles parses the Go source files within directory dir and
+// returns the ASTs of the ones that could be at least partially parsed,
+// along with a list of I/O and parse errors encountered.
+//
+// I/O is done via ctxt, which may specify a virtual file system.
+// displayPath is used to transform the filenames attached to the ASTs.
+//
+func parseFiles(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, files []string, mode parser.Mode) ([]*ast.File, []error) {
+       if displayPath == nil {
+               displayPath = func(path string) string { return path }
+       }
+       var wg sync.WaitGroup
+       n := len(files)
+       parsed := make([]*ast.File, n)
+       errors := make([]error, n)
+       for i, file := range files {
+               if !buildutil.IsAbsPath(ctxt, file) {
+                       file = buildutil.JoinPath(ctxt, dir, file)
+               }
+               wg.Add(1)
+               go func(i int, file string) {
+                       ioLimit <- true // wait
+                       defer func() {
+                               wg.Done()
+                               <-ioLimit // signal
+                       }()
+                       var rd io.ReadCloser
+                       var err error
+                       if ctxt.OpenFile != nil {
+                               rd, err = ctxt.OpenFile(file)
+                       } else {
+                               rd, err = os.Open(file)
+                       }
+                       if err != nil {
+                               errors[i] = err // open failed
+                               return
+                       }
+
+                       // ParseFile may return both an AST and an error.
+                       parsed[i], errors[i] = parser.ParseFile(fset, displayPath(file), rd, mode)
+                       rd.Close()
+               }(i, file)
+       }
+       wg.Wait()
+
+       // Eliminate nils, preserving order.
+       var o int
+       for _, f := range parsed {
+               if f != nil {
+                       parsed[o] = f
+                       o++
+               }
+       }
+       parsed = parsed[:o]
+
+       o = 0
+       for _, err := range errors {
+               if err != nil {
+                       errors[o] = err
+                       o++
+               }
+       }
+       errors = errors[:o]
+
+       return parsed, errors
+}
+
+// scanImports returns the set of all import paths from all
+// import specs in the specified files.
+func scanImports(files []*ast.File) map[string]bool {
+       imports := make(map[string]bool)
+       for _, f := range files {
+               for _, decl := range f.Decls {
+                       if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
+                               for _, spec := range decl.Specs {
+                                       spec := spec.(*ast.ImportSpec)
+
+                                       // NB: do not assume the program is well-formed!
+                                       path, err := strconv.Unquote(spec.Path.Value)
+                                       if err != nil {
+                                               continue // quietly ignore the error
+                                       }
+                                       if path == "C" {
+                                               continue // skip pseudopackage
+                                       }
+                                       imports[path] = true
+                               }
+                       }
+               }
+       }
+       return imports
+}
+
+// ---------- Internal helpers ----------
+
+// TODO(adonovan): make this a method: func (*token.File) Contains(token.Pos)
+func tokenFileContainsPos(f *token.File, pos token.Pos) bool {
+       p := int(pos)
+       base := f.Base()
+       return base <= p && p < base+f.Size()
+}