Add generated file

This PR adds generated files under pkg/client and vendor folder.

vendor/golang.org/x/tools/go/buildutil/allpackages.go

@@ -0,0 +1,198 @@
+// Copyright 2014 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 buildutil provides utilities related to the go/build
+// package in the standard library.
+//
+// All I/O is done via the build.Context file system interface, which must
+// be concurrency-safe.
+package buildutil // import "golang.org/x/tools/go/buildutil"
+
+import (
+	"go/build"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+)
+
+// AllPackages returns the package path of each Go package in any source
+// directory of the specified build context (e.g. $GOROOT or an element
+// of $GOPATH).  Errors are ignored.  The results are sorted.
+// All package paths are canonical, and thus may contain "/vendor/".
+//
+// The result may include import paths for directories that contain no
+// *.go files, such as "archive" (in $GOROOT/src).
+//
+// All I/O is done via the build.Context file system interface,
+// which must be concurrency-safe.
+//
+func AllPackages(ctxt *build.Context) []string {
+	var list []string
+	ForEachPackage(ctxt, func(pkg string, _ error) {
+		list = append(list, pkg)
+	})
+	sort.Strings(list)
+	return list
+}
+
+// ForEachPackage calls the found function with the package path of
+// each Go package it finds in any source directory of the specified
+// build context (e.g. $GOROOT or an element of $GOPATH).
+// All package paths are canonical, and thus may contain "/vendor/".
+//
+// If the package directory exists but could not be read, the second
+// argument to the found function provides the error.
+//
+// All I/O is done via the build.Context file system interface,
+// which must be concurrency-safe.
+//
+func ForEachPackage(ctxt *build.Context, found func(importPath string, err error)) {
+	ch := make(chan item)
+
+	var wg sync.WaitGroup
+	for _, root := range ctxt.SrcDirs() {
+		root := root
+		wg.Add(1)
+		go func() {
+			allPackages(ctxt, root, ch)
+			wg.Done()
+		}()
+	}
+	go func() {
+		wg.Wait()
+		close(ch)
+	}()
+
+	// All calls to found occur in the caller's goroutine.
+	for i := range ch {
+		found(i.importPath, i.err)
+	}
+}
+
+type item struct {
+	importPath string
+	err        error // (optional)
+}
+
+// We use a process-wide counting semaphore to limit
+// the number of parallel calls to ReadDir.
+var ioLimit = make(chan bool, 20)
+
+func allPackages(ctxt *build.Context, root string, ch chan<- item) {
+	root = filepath.Clean(root) + string(os.PathSeparator)
+
+	var wg sync.WaitGroup
+
+	var walkDir func(dir string)
+	walkDir = func(dir string) {
+		// Avoid .foo, _foo, and testdata directory trees.
+		base := filepath.Base(dir)
+		if base == "" || base[0] == '.' || base[0] == '_' || base == "testdata" {
+			return
+		}
+
+		pkg := filepath.ToSlash(strings.TrimPrefix(dir, root))
+
+		// Prune search if we encounter any of these import paths.
+		switch pkg {
+		case "builtin":
+			return
+		}
+
+		ioLimit <- true
+		files, err := ReadDir(ctxt, dir)
+		<-ioLimit
+		if pkg != "" || err != nil {
+			ch <- item{pkg, err}
+		}
+		for _, fi := range files {
+			fi := fi
+			if fi.IsDir() {
+				wg.Add(1)
+				go func() {
+					walkDir(filepath.Join(dir, fi.Name()))
+					wg.Done()
+				}()
+			}
+		}
+	}
+
+	walkDir(root)
+	wg.Wait()
+}
+
+// ExpandPatterns returns the set of packages matched by patterns,
+// which may have the following forms:
+//
+//		golang.org/x/tools/cmd/guru     # a single package
+//		golang.org/x/tools/...          # all packages beneath dir
+//		...                             # the entire workspace.
+//
+// Order is significant: a pattern preceded by '-' removes matching
+// packages from the set.  For example, these patterns match all encoding
+// packages except encoding/xml:
+//
+// 	encoding/... -encoding/xml
+//
+// A trailing slash in a pattern is ignored.  (Path components of Go
+// package names are separated by slash, not the platform's path separator.)
+//
+func ExpandPatterns(ctxt *build.Context, patterns []string) map[string]bool {
+	// TODO(adonovan): support other features of 'go list':
+	// - "std"/"cmd"/"all" meta-packages
+	// - "..." not at the end of a pattern
+	// - relative patterns using "./" or "../" prefix
+
+	pkgs := make(map[string]bool)
+	doPkg := func(pkg string, neg bool) {
+		if neg {
+			delete(pkgs, pkg)
+		} else {
+			pkgs[pkg] = true
+		}
+	}
+
+	// Scan entire workspace if wildcards are present.
+	// TODO(adonovan): opt: scan only the necessary subtrees of the workspace.
+	var all []string
+	for _, arg := range patterns {
+		if strings.HasSuffix(arg, "...") {
+			all = AllPackages(ctxt)
+			break
+		}
+	}
+
+	for _, arg := range patterns {
+		if arg == "" {
+			continue
+		}
+
+		neg := arg[0] == '-'
+		if neg {
+			arg = arg[1:]
+		}
+
+		if arg == "..." {
+			// ... matches all packages
+			for _, pkg := range all {
+				doPkg(pkg, neg)
+			}
+		} else if dir := strings.TrimSuffix(arg, "/..."); dir != arg {
+			// dir/... matches all packages beneath dir
+			for _, pkg := range all {
+				if strings.HasPrefix(pkg, dir) &&
+					(len(pkg) == len(dir) || pkg[len(dir)] == '/') {
+					doPkg(pkg, neg)
+				}
+			}
+		} else {
+			// single package
+			doPkg(strings.TrimSuffix(arg, "/"), neg)
+		}
+	}
+
+	return pkgs
+}

vendor/golang.org/x/tools/go/buildutil/allpackages_test.go

@@ -0,0 +1,83 @@
+// Copyright 2014 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.
+
+// Incomplete source tree on Android.
+
+// +build !android
+
+package buildutil_test
+
+import (
+	"go/build"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestAllPackages(t *testing.T) {
+	if runtime.Compiler == "gccgo" {
+		t.Skip("gccgo has no standard packages")
+	}
+
+	all := buildutil.AllPackages(&build.Default)
+
+	set := make(map[string]bool)
+	for _, pkg := range all {
+		set[pkg] = true
+	}
+
+	const wantAtLeast = 250
+	if len(all) < wantAtLeast {
+		t.Errorf("Found only %d packages, want at least %d", len(all), wantAtLeast)
+	}
+
+	for _, want := range []string{"fmt", "crypto/sha256", "golang.org/x/tools/go/buildutil"} {
+		if !set[want] {
+			t.Errorf("Package %q not found; got %s", want, all)
+		}
+	}
+}
+
+func TestExpandPatterns(t *testing.T) {
+	tree := make(map[string]map[string]string)
+	for _, pkg := range []string{
+		"encoding",
+		"encoding/xml",
+		"encoding/hex",
+		"encoding/json",
+		"fmt",
+	} {
+		tree[pkg] = make(map[string]string)
+	}
+	ctxt := buildutil.FakeContext(tree)
+
+	for _, test := range []struct {
+		patterns string
+		want     string
+	}{
+		{"", ""},
+		{"fmt", "fmt"},
+		{"nosuchpkg", "nosuchpkg"},
+		{"nosuchdir/...", ""},
+		{"...", "encoding encoding/hex encoding/json encoding/xml fmt"},
+		{"encoding/... -encoding/xml", "encoding encoding/hex encoding/json"},
+		{"... -encoding/...", "fmt"},
+		{"encoding", "encoding"},
+		{"encoding/", "encoding"},
+	} {
+		var pkgs []string
+		for pkg := range buildutil.ExpandPatterns(ctxt, strings.Fields(test.patterns)) {
+			pkgs = append(pkgs, pkg)
+		}
+		sort.Strings(pkgs)
+		got := strings.Join(pkgs, " ")
+		if got != test.want {
+			t.Errorf("ExpandPatterns(%s) = %s, want %s",
+				test.patterns, got, test.want)
+		}
+	}
+}

vendor/golang.org/x/tools/go/buildutil/fakecontext.go

@@ -0,0 +1,109 @@
+package buildutil
+
+import (
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+// FakeContext returns a build.Context for the fake file tree specified
+// by pkgs, which maps package import paths to a mapping from file base
+// names to contents.
+//
+// The fake Context has a GOROOT of "/go" and no GOPATH, and overrides
+// the necessary file access methods to read from memory instead of the
+// real file system.
+//
+// Unlike a real file tree, the fake one has only two levels---packages
+// and files---so ReadDir("/go/src/") returns all packages under
+// /go/src/ including, for instance, "math" and "math/big".
+// ReadDir("/go/src/math/big") would return all the files in the
+// "math/big" package.
+//
+func FakeContext(pkgs map[string]map[string]string) *build.Context {
+	clean := func(filename string) string {
+		f := path.Clean(filepath.ToSlash(filename))
+		// Removing "/go/src" while respecting segment
+		// boundaries has this unfortunate corner case:
+		if f == "/go/src" {
+			return ""
+		}
+		return strings.TrimPrefix(f, "/go/src/")
+	}
+
+	ctxt := build.Default // copy
+	ctxt.GOROOT = "/go"
+	ctxt.GOPATH = ""
+	ctxt.Compiler = "gc"
+	ctxt.IsDir = func(dir string) bool {
+		dir = clean(dir)
+		if dir == "" {
+			return true // needed by (*build.Context).SrcDirs
+		}
+		return pkgs[dir] != nil
+	}
+	ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
+		dir = clean(dir)
+		var fis []os.FileInfo
+		if dir == "" {
+			// enumerate packages
+			for importPath := range pkgs {
+				fis = append(fis, fakeDirInfo(importPath))
+			}
+		} else {
+			// enumerate files of package
+			for basename := range pkgs[dir] {
+				fis = append(fis, fakeFileInfo(basename))
+			}
+		}
+		sort.Sort(byName(fis))
+		return fis, nil
+	}
+	ctxt.OpenFile = func(filename string) (io.ReadCloser, error) {
+		filename = clean(filename)
+		dir, base := path.Split(filename)
+		content, ok := pkgs[path.Clean(dir)][base]
+		if !ok {
+			return nil, fmt.Errorf("file not found: %s", filename)
+		}
+		return ioutil.NopCloser(strings.NewReader(content)), nil
+	}
+	ctxt.IsAbsPath = func(path string) bool {
+		path = filepath.ToSlash(path)
+		// Don't rely on the default (filepath.Path) since on
+		// Windows, it reports virtual paths as non-absolute.
+		return strings.HasPrefix(path, "/")
+	}
+	return &ctxt
+}
+
+type byName []os.FileInfo
+
+func (s byName) Len() int           { return len(s) }
+func (s byName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byName) Less(i, j int) bool { return s[i].Name() < s[j].Name() }
+
+type fakeFileInfo string
+
+func (fi fakeFileInfo) Name() string    { return string(fi) }
+func (fakeFileInfo) Sys() interface{}   { return nil }
+func (fakeFileInfo) ModTime() time.Time { return time.Time{} }
+func (fakeFileInfo) IsDir() bool        { return false }
+func (fakeFileInfo) Size() int64        { return 0 }
+func (fakeFileInfo) Mode() os.FileMode  { return 0644 }
+
+type fakeDirInfo string
+
+func (fd fakeDirInfo) Name() string    { return string(fd) }
+func (fakeDirInfo) Sys() interface{}   { return nil }
+func (fakeDirInfo) ModTime() time.Time { return time.Time{} }
+func (fakeDirInfo) IsDir() bool        { return true }
+func (fakeDirInfo) Size() int64        { return 0 }
+func (fakeDirInfo) Mode() os.FileMode  { return 0755 }

vendor/golang.org/x/tools/go/buildutil/overlay.go

@@ -0,0 +1,103 @@
+// Copyright 2016 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 buildutil
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// OverlayContext overlays a build.Context with additional files from
+// a map. Files in the map take precedence over other files.
+//
+// In addition to plain string comparison, two file names are
+// considered equal if their base names match and their directory
+// components point at the same directory on the file system. That is,
+// symbolic links are followed for directories, but not files.
+//
+// A common use case for OverlayContext is to allow editors to pass in
+// a set of unsaved, modified files.
+//
+// Currently, only the Context.OpenFile function will respect the
+// overlay. This may change in the future.
+func OverlayContext(orig *build.Context, overlay map[string][]byte) *build.Context {
+	// TODO(dominikh): Implement IsDir, HasSubdir and ReadDir
+
+	rc := func(data []byte) (io.ReadCloser, error) {
+		return ioutil.NopCloser(bytes.NewBuffer(data)), nil
+	}
+
+	copy := *orig // make a copy
+	ctxt := &copy
+	ctxt.OpenFile = func(path string) (io.ReadCloser, error) {
+		// Fast path: names match exactly.
+		if content, ok := overlay[path]; ok {
+			return rc(content)
+		}
+
+		// Slow path: check for same file under a different
+		// alias, perhaps due to a symbolic link.
+		for filename, content := range overlay {
+			if sameFile(path, filename) {
+				return rc(content)
+			}
+		}
+
+		return OpenFile(orig, path)
+	}
+	return ctxt
+}
+
+// ParseOverlayArchive parses an archive containing Go files and their
+// contents. The result is intended to be used with OverlayContext.
+//
+//
+// Archive format
+//
+// The archive consists of a series of files. Each file consists of a
+// name, a decimal file size and the file contents, separated by
+// newlinews. No newline follows after the file contents.
+func ParseOverlayArchive(archive io.Reader) (map[string][]byte, error) {
+	overlay := make(map[string][]byte)
+	r := bufio.NewReader(archive)
+	for {
+		// Read file name.
+		filename, err := r.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break // OK
+			}
+			return nil, fmt.Errorf("reading archive file name: %v", err)
+		}
+		filename = filepath.Clean(strings.TrimSpace(filename))
+
+		// Read file size.
+		sz, err := r.ReadString('\n')
+		if err != nil {
+			return nil, fmt.Errorf("reading size of archive file %s: %v", filename, err)
+		}
+		sz = strings.TrimSpace(sz)
+		size, err := strconv.ParseUint(sz, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("parsing size of archive file %s: %v", filename, err)
+		}
+
+		// Read file content.
+		content := make([]byte, size)
+		if _, err := io.ReadFull(r, content); err != nil {
+			return nil, fmt.Errorf("reading archive file %s: %v", filename, err)
+		}
+		overlay[filename] = content
+	}
+
+	return overlay, nil
+}

vendor/golang.org/x/tools/go/buildutil/overlay_test.go

@@ -0,0 +1,70 @@
+package buildutil_test
+
+import (
+	"go/build"
+	"io/ioutil"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestParseOverlayArchive(t *testing.T) {
+	var tt = []struct {
+		in     string
+		out    map[string][]byte
+		hasErr bool
+	}{
+		{
+			"a.go\n5\n12345",
+			map[string][]byte{"a.go": []byte("12345")},
+			false,
+		},
+		{
+			"a.go\n5\n1234",
+			nil,
+			true,
+		},
+		{
+			"a.go\n5\n12345b.go\n4\n1234",
+			map[string][]byte{"a.go": []byte("12345"), "b.go": []byte("1234")},
+			false,
+		},
+	}
+
+	for _, test := range tt {
+		got, err := buildutil.ParseOverlayArchive(strings.NewReader(test.in))
+		if err == nil && test.hasErr {
+			t.Errorf("expected error for %q", test.in)
+		}
+		if err != nil && !test.hasErr {
+			t.Errorf("unexpected error %v for %q", err, test.in)
+		}
+		if !reflect.DeepEqual(got, test.out) {
+			t.Errorf("got %#v, want %#v", got, test.out)
+		}
+	}
+}
+
+func TestOverlay(t *testing.T) {
+	ctx := &build.Default
+	ov := map[string][]byte{
+		"/somewhere/a.go": []byte("file contents"),
+	}
+	names := []string{"/somewhere/a.go", "/somewhere//a.go"}
+	ctx = buildutil.OverlayContext(ctx, ov)
+	for _, name := range names {
+		f, err := buildutil.OpenFile(ctx, name)
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		b, err := ioutil.ReadAll(f)
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		if got, expected := string(b), string(ov["/somewhere/a.go"]); got != expected {
+			t.Errorf("read %q, expected %q", got, expected)
+		}
+	}
+}

vendor/golang.org/x/tools/go/buildutil/tags.go

@@ -0,0 +1,75 @@
+package buildutil
+
+// This logic was copied from stringsFlag from $GOROOT/src/cmd/go/build.go.
+
+import "fmt"
+
+const TagsFlagDoc = "a list of `build tags` to consider satisfied during the build. " +
+	"For more information about build tags, see the description of " +
+	"build constraints in the documentation for the go/build package"
+
+// TagsFlag is an implementation of the flag.Value and flag.Getter interfaces that parses
+// a flag value in the same manner as go build's -tags flag and
+// populates a []string slice.
+//
+// See $GOROOT/src/go/build/doc.go for description of build tags.
+// See $GOROOT/src/cmd/go/doc.go for description of 'go build -tags' flag.
+//
+// Example:
+// 	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+type TagsFlag []string
+
+func (v *TagsFlag) Set(s string) error {
+	var err error
+	*v, err = splitQuotedFields(s)
+	if *v == nil {
+		*v = []string{}
+	}
+	return err
+}
+
+func (v *TagsFlag) Get() interface{} { return *v }
+
+func splitQuotedFields(s string) ([]string, error) {
+	// Split fields allowing '' or "" around elements.
+	// Quotes further inside the string do not count.
+	var f []string
+	for len(s) > 0 {
+		for len(s) > 0 && isSpaceByte(s[0]) {
+			s = s[1:]
+		}
+		if len(s) == 0 {
+			break
+		}
+		// Accepted quoted string. No unescaping inside.
+		if s[0] == '"' || s[0] == '\'' {
+			quote := s[0]
+			s = s[1:]
+			i := 0
+			for i < len(s) && s[i] != quote {
+				i++
+			}
+			if i >= len(s) {
+				return nil, fmt.Errorf("unterminated %c string", quote)
+			}
+			f = append(f, s[:i])
+			s = s[i+1:]
+			continue
+		}
+		i := 0
+		for i < len(s) && !isSpaceByte(s[i]) {
+			i++
+		}
+		f = append(f, s[:i])
+		s = s[i:]
+	}
+	return f, nil
+}
+
+func (v *TagsFlag) String() string {
+	return "<tagsFlag>"
+}
+
+func isSpaceByte(c byte) bool {
+	return c == ' ' || c == '\t' || c == '\n' || c == '\r'
+}

vendor/golang.org/x/tools/go/buildutil/tags_test.go

@@ -0,0 +1,28 @@
+package buildutil_test
+
+import (
+	"flag"
+	"go/build"
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestTags(t *testing.T) {
+	f := flag.NewFlagSet("TestTags", flag.PanicOnError)
+	var ctxt build.Context
+	f.Var((*buildutil.TagsFlag)(&ctxt.BuildTags), "tags", buildutil.TagsFlagDoc)
+	f.Parse([]string{"-tags", ` 'one'"two"	'three "four"'`, "rest"})
+
+	// BuildTags
+	want := []string{"one", "two", "three \"four\""}
+	if !reflect.DeepEqual(ctxt.BuildTags, want) {
+		t.Errorf("BuildTags = %q, want %q", ctxt.BuildTags, want)
+	}
+
+	// Args()
+	if want := []string{"rest"}; !reflect.DeepEqual(f.Args(), want) {
+		t.Errorf("f.Args() = %q, want %q", f.Args(), want)
+	}
+}

vendor/golang.org/x/tools/go/buildutil/util.go

@@ -0,0 +1,212 @@
+// Copyright 2014 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 buildutil
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+// ParseFile behaves like parser.ParseFile,
+// but uses the build context's file system interface, if any.
+//
+// If file is not absolute (as defined by IsAbsPath), the (dir, file)
+// components are joined using JoinPath; dir must be absolute.
+//
+// The displayPath function, if provided, is used to transform the
+// filename that will be attached to the ASTs.
+//
+// TODO(adonovan): call this from go/loader.parseFiles when the tree thaws.
+//
+func ParseFile(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, file string, mode parser.Mode) (*ast.File, error) {
+	if !IsAbsPath(ctxt, file) {
+		file = JoinPath(ctxt, dir, file)
+	}
+	rd, err := OpenFile(ctxt, file)
+	if err != nil {
+		return nil, err
+	}
+	defer rd.Close() // ignore error
+	if displayPath != nil {
+		file = displayPath(file)
+	}
+	return parser.ParseFile(fset, file, rd, mode)
+}
+
+// ContainingPackage returns the package containing filename.
+//
+// If filename is not absolute, it is interpreted relative to working directory dir.
+// All I/O is via the build context's file system interface, if any.
+//
+// The '...Files []string' fields of the resulting build.Package are not
+// populated (build.FindOnly mode).
+//
+func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Package, error) {
+	if !IsAbsPath(ctxt, filename) {
+		filename = JoinPath(ctxt, dir, filename)
+	}
+
+	// We must not assume the file tree uses
+	// "/" always,
+	// `\` always,
+	// or os.PathSeparator (which varies by platform),
+	// but to make any progress, we are forced to assume that
+	// paths will not use `\` unless the PathSeparator
+	// is also `\`, thus we can rely on filepath.ToSlash for some sanity.
+
+	dirSlash := path.Dir(filepath.ToSlash(filename)) + "/"
+
+	// We assume that no source root (GOPATH[i] or GOROOT) contains any other.
+	for _, srcdir := range ctxt.SrcDirs() {
+		srcdirSlash := filepath.ToSlash(srcdir) + "/"
+		if importPath, ok := HasSubdir(ctxt, srcdirSlash, dirSlash); ok {
+			return ctxt.Import(importPath, dir, build.FindOnly)
+		}
+	}
+
+	return nil, fmt.Errorf("can't find package containing %s", filename)
+}
+
+// -- Effective methods of file system interface -------------------------
+
+// (go/build.Context defines these as methods, but does not export them.)
+
+// hasSubdir calls ctxt.HasSubdir (if not nil) or else uses
+// the local file system to answer the question.
+func HasSubdir(ctxt *build.Context, root, dir string) (rel string, ok bool) {
+	if f := ctxt.HasSubdir; f != nil {
+		return f(root, dir)
+	}
+
+	// Try using paths we received.
+	if rel, ok = hasSubdir(root, dir); ok {
+		return
+	}
+
+	// Try expanding symlinks and comparing
+	// expanded against unexpanded and
+	// expanded against expanded.
+	rootSym, _ := filepath.EvalSymlinks(root)
+	dirSym, _ := filepath.EvalSymlinks(dir)
+
+	if rel, ok = hasSubdir(rootSym, dir); ok {
+		return
+	}
+	if rel, ok = hasSubdir(root, dirSym); ok {
+		return
+	}
+	return hasSubdir(rootSym, dirSym)
+}
+
+func hasSubdir(root, dir string) (rel string, ok bool) {
+	const sep = string(filepath.Separator)
+	root = filepath.Clean(root)
+	if !strings.HasSuffix(root, sep) {
+		root += sep
+	}
+
+	dir = filepath.Clean(dir)
+	if !strings.HasPrefix(dir, root) {
+		return "", false
+	}
+
+	return filepath.ToSlash(dir[len(root):]), true
+}
+
+// FileExists returns true if the specified file exists,
+// using the build context's file system interface.
+func FileExists(ctxt *build.Context, path string) bool {
+	if ctxt.OpenFile != nil {
+		r, err := ctxt.OpenFile(path)
+		if err != nil {
+			return false
+		}
+		r.Close() // ignore error
+		return true
+	}
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// OpenFile behaves like os.Open,
+// but uses the build context's file system interface, if any.
+func OpenFile(ctxt *build.Context, path string) (io.ReadCloser, error) {
+	if ctxt.OpenFile != nil {
+		return ctxt.OpenFile(path)
+	}
+	return os.Open(path)
+}
+
+// IsAbsPath behaves like filepath.IsAbs,
+// but uses the build context's file system interface, if any.
+func IsAbsPath(ctxt *build.Context, path string) bool {
+	if ctxt.IsAbsPath != nil {
+		return ctxt.IsAbsPath(path)
+	}
+	return filepath.IsAbs(path)
+}
+
+// JoinPath behaves like filepath.Join,
+// but uses the build context's file system interface, if any.
+func JoinPath(ctxt *build.Context, path ...string) string {
+	if ctxt.JoinPath != nil {
+		return ctxt.JoinPath(path...)
+	}
+	return filepath.Join(path...)
+}
+
+// IsDir behaves like os.Stat plus IsDir,
+// but uses the build context's file system interface, if any.
+func IsDir(ctxt *build.Context, path string) bool {
+	if ctxt.IsDir != nil {
+		return ctxt.IsDir(path)
+	}
+	fi, err := os.Stat(path)
+	return err == nil && fi.IsDir()
+}
+
+// ReadDir behaves like ioutil.ReadDir,
+// but uses the build context's file system interface, if any.
+func ReadDir(ctxt *build.Context, path string) ([]os.FileInfo, error) {
+	if ctxt.ReadDir != nil {
+		return ctxt.ReadDir(path)
+	}
+	return ioutil.ReadDir(path)
+}
+
+// SplitPathList behaves like filepath.SplitList,
+// but uses the build context's file system interface, if any.
+func SplitPathList(ctxt *build.Context, s string) []string {
+	if ctxt.SplitPathList != nil {
+		return ctxt.SplitPathList(s)
+	}
+	return filepath.SplitList(s)
+}
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+//
+func sameFile(x, y string) bool {
+	if path.Clean(x) == path.Clean(y) {
+		return true
+	}
+	if filepath.Base(x) == filepath.Base(y) { // (optimisation)
+		if xi, err := os.Stat(x); err == nil {
+			if yi, err := os.Stat(y); err == nil {
+				return os.SameFile(xi, yi)
+			}
+		}
+	}
+	return false
+}

vendor/golang.org/x/tools/go/buildutil/util_test.go

@@ -0,0 +1,85 @@
+// Copyright 2014 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 buildutil_test
+
+import (
+	"go/build"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func TestContainingPackage(t *testing.T) {
+	if runtime.Compiler == "gccgo" {
+		t.Skip("gccgo has no GOROOT")
+	}
+
+	// unvirtualized:
+	goroot := runtime.GOROOT()
+	gopath := gopathContainingTools(t)
+
+	type Test struct {
+		gopath, filename, wantPkg string
+	}
+
+	tests := []Test{
+		{gopath, goroot + "/src/fmt/print.go", "fmt"},
+		{gopath, goroot + "/src/encoding/json/foo.go", "encoding/json"},
+		{gopath, goroot + "/src/encoding/missing/foo.go", "(not found)"},
+		{gopath, gopath + "/src/golang.org/x/tools/go/buildutil/util_test.go",
+			"golang.org/x/tools/go/buildutil"},
+	}
+
+	if runtime.GOOS != "windows" && runtime.GOOS != "plan9" {
+		// Make a symlink to gopath for test
+		tmp, err := ioutil.TempDir(os.TempDir(), "go")
+		if err != nil {
+			t.Errorf("Unable to create a temporary directory in %s", os.TempDir())
+		}
+
+		defer os.RemoveAll(tmp)
+
+		// symlink between $GOPATH/src and /tmp/go/src
+		// in order to test all possible symlink cases
+		if err := os.Symlink(gopath+"/src", tmp+"/src"); err != nil {
+			t.Fatal(err)
+		}
+		tests = append(tests, []Test{
+			{gopath, tmp + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+			{tmp, gopath + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+			{tmp, tmp + "/src/golang.org/x/tools/go/buildutil/util_test.go", "golang.org/x/tools/go/buildutil"},
+		}...)
+	}
+
+	for _, test := range tests {
+		var got string
+		var buildContext = build.Default
+		buildContext.GOPATH = test.gopath
+		bp, err := buildutil.ContainingPackage(&buildContext, ".", test.filename)
+		if err != nil {
+			got = "(not found)"
+		} else {
+			got = bp.ImportPath
+		}
+		if got != test.wantPkg {
+			t.Errorf("ContainingPackage(%q) = %s, want %s", test.filename, got, test.wantPkg)
+		}
+	}
+
+	// TODO(adonovan): test on virtualized GOPATH too.
+}
+
+// gopathContainingTools returns the path of the GOPATH workspace
+// with golang.org/x/tools, or fails the test if it can't locate it.
+func gopathContainingTools(t *testing.T) string {
+	p, err := build.Import("golang.org/x/tools", "", build.FindOnly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return p.Root
+}

vendor/golang.org/x/tools/go/buildutil/util_windows_test.go

@@ -0,0 +1,48 @@
+// Copyright 2015 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 buildutil_test
+
+import (
+	"fmt"
+	"go/build"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+func testContainingPackageCaseFold(file, want string) error {
+	bp, err := buildutil.ContainingPackage(&build.Default, ".", file)
+	if err != nil {
+		return err
+	}
+	if got := bp.ImportPath; got != want {
+		return fmt.Errorf("ContainingPackage(%q) = %s, want %s", file, got, want)
+	}
+	return nil
+}
+
+func TestContainingPackageCaseFold(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), `src\fmt\print.go`)
+	err := testContainingPackageCaseFold(path, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+	vol := filepath.VolumeName(path)
+	if len(vol) != 2 || vol[1] != ':' {
+		t.Fatalf("GOROOT path has unexpected volume name: %v", vol)
+	}
+	rest := path[len(vol):]
+	err = testContainingPackageCaseFold(strings.ToUpper(vol)+rest, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+	err = testContainingPackageCaseFold(strings.ToLower(vol)+rest, "fmt")
+	if err != nil {
+		t.Error(err)
+	}
+}