mirror of
https://github.com/golang/go
synced 2024-11-05 17:46:16 -07:00
757ca719ca
For various reasons we need an internal-facing imports API. Move imports to internal/imports, leaving behind a small wrapper package. The wrapper package captures the globals at time of call into the options struct. Also converts the last goimports tests to use the test helpers, and fixes go/packages in module mode to work with empty modules, which was necessary to get those last tests converted. Change-Id: Ib1212c67908741a1800b992ef1935d563c6ade32 Reviewed-on: https://go-review.googlesource.com/c/tools/+/175437 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Cottrell <iancottrell@google.com>
174 lines
3.7 KiB
Go
174 lines
3.7 KiB
Go
// +build ignore
|
|
|
|
// 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.
|
|
|
|
// Command mkindex creates the file "pkgindex.go" containing an index of the Go
|
|
// standard library. The file is intended to be built as part of the imports
|
|
// package, so that the package may be used in environments where a GOROOT is
|
|
// not available (such as App Engine).
|
|
package imports
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"go/ast"
|
|
"go/build"
|
|
"go/format"
|
|
"go/parser"
|
|
"go/token"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
pkgIndex = make(map[string][]pkg)
|
|
exports = make(map[string]map[string]bool)
|
|
)
|
|
|
|
func main() {
|
|
// Don't use GOPATH.
|
|
ctx := build.Default
|
|
ctx.GOPATH = ""
|
|
|
|
// Populate pkgIndex global from GOROOT.
|
|
for _, path := range ctx.SrcDirs() {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
log.Print(err)
|
|
continue
|
|
}
|
|
children, err := f.Readdir(-1)
|
|
f.Close()
|
|
if err != nil {
|
|
log.Print(err)
|
|
continue
|
|
}
|
|
for _, child := range children {
|
|
if child.IsDir() {
|
|
loadPkg(path, child.Name())
|
|
}
|
|
}
|
|
}
|
|
// Populate exports global.
|
|
for _, ps := range pkgIndex {
|
|
for _, p := range ps {
|
|
e := loadExports(p.dir)
|
|
if e != nil {
|
|
exports[p.dir] = e
|
|
}
|
|
}
|
|
}
|
|
|
|
// Construct source file.
|
|
var buf bytes.Buffer
|
|
fmt.Fprint(&buf, pkgIndexHead)
|
|
fmt.Fprintf(&buf, "var pkgIndexMaster = %#v\n", pkgIndex)
|
|
fmt.Fprintf(&buf, "var exportsMaster = %#v\n", exports)
|
|
src := buf.Bytes()
|
|
|
|
// Replace main.pkg type name with pkg.
|
|
src = bytes.Replace(src, []byte("main.pkg"), []byte("pkg"), -1)
|
|
// Replace actual GOROOT with "/go".
|
|
src = bytes.Replace(src, []byte(ctx.GOROOT), []byte("/go"), -1)
|
|
// Add some line wrapping.
|
|
src = bytes.Replace(src, []byte("}, "), []byte("},\n"), -1)
|
|
src = bytes.Replace(src, []byte("true, "), []byte("true,\n"), -1)
|
|
|
|
var err error
|
|
src, err = format.Source(src)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
// Write out source file.
|
|
err = ioutil.WriteFile("pkgindex.go", src, 0644)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
const pkgIndexHead = `package imports
|
|
|
|
func init() {
|
|
pkgIndexOnce.Do(func() {
|
|
pkgIndex.m = pkgIndexMaster
|
|
})
|
|
loadExports = func(dir string) map[string]bool {
|
|
return exportsMaster[dir]
|
|
}
|
|
}
|
|
`
|
|
|
|
type pkg struct {
|
|
importpath string // full pkg import path, e.g. "net/http"
|
|
dir string // absolute file path to pkg directory e.g. "/usr/lib/go/src/fmt"
|
|
}
|
|
|
|
var fset = token.NewFileSet()
|
|
|
|
func loadPkg(root, importpath string) {
|
|
shortName := path.Base(importpath)
|
|
if shortName == "testdata" {
|
|
return
|
|
}
|
|
|
|
dir := filepath.Join(root, importpath)
|
|
pkgIndex[shortName] = append(pkgIndex[shortName], pkg{
|
|
importpath: importpath,
|
|
dir: dir,
|
|
})
|
|
|
|
pkgDir, err := os.Open(dir)
|
|
if err != nil {
|
|
return
|
|
}
|
|
children, err := pkgDir.Readdir(-1)
|
|
pkgDir.Close()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, child := range children {
|
|
name := child.Name()
|
|
if name == "" {
|
|
continue
|
|
}
|
|
if c := name[0]; c == '.' || ('0' <= c && c <= '9') {
|
|
continue
|
|
}
|
|
if child.IsDir() {
|
|
loadPkg(root, filepath.Join(importpath, name))
|
|
}
|
|
}
|
|
}
|
|
|
|
func loadExports(dir string) map[string]bool {
|
|
exports := make(map[string]bool)
|
|
buildPkg, err := build.ImportDir(dir, 0)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "no buildable Go source files in") {
|
|
return nil
|
|
}
|
|
log.Printf("could not import %q: %v", dir, err)
|
|
return nil
|
|
}
|
|
for _, file := range buildPkg.GoFiles {
|
|
f, err := parser.ParseFile(fset, filepath.Join(dir, file), nil, 0)
|
|
if err != nil {
|
|
log.Printf("could not parse %q: %v", file, err)
|
|
continue
|
|
}
|
|
for name := range f.Scope.Objects {
|
|
if ast.IsExported(name) {
|
|
exports[name] = true
|
|
}
|
|
}
|
|
}
|
|
return exports
|
|
}
|