435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
125 lines
2.9 KiB
Go
125 lines
2.9 KiB
Go
// 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()
|
|
}
|