From bf09a8c9708104c2f2b172d3a2e5ef80198d5256 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 12 Mar 2012 17:03:29 -0400
Subject: [PATCH] undo CL 5754088 / cae9a7c0db06
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

broke builders

««« original CL description
cmd/go: respect $GOBIN always

Before, we only consulted $GOBIN for source code
found in $GOROOT, but that's confusing to explain
and less useful.  The new behavior lets users set
GOBIN=$HOME/bin and have all go-compiled binaries
installed there.

Fixes #3269.

R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/5754088
»»»

TBR=bradfitz
CC=golang-dev
https://golang.org/cl/5794065
---
 doc/install-source.html |  5 ++---
 src/cmd/go/build.go     | 35 +++++++++++++++++------------------
 src/cmd/go/doc.go       |  4 +---
 src/cmd/go/help.go      |  4 +---
 src/cmd/go/pkg.go       |  4 +---
 5 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/doc/install-source.html b/doc/install-source.html
index 4673850f42d..82ff8e740d0 100644
--- a/doc/install-source.html
+++ b/doc/install-source.html
@@ -393,12 +393,11 @@ For example, you should not set <code>$GOHOSTARCH</code> to
 
 <p><code>$GOBIN</code>
 <p>
-The location where Go binaries will be installed.
+The location where binaries from the main repository will be installed.
+XXX THIS MAY CHANGE TO BE AN OVERRIDE EVEN FOR GOPATH ENTRIES XXX
 The default is <code>$GOROOT/bin</code>.
 After installing, you will want to arrange to add this
 directory to your <code>$PATH</code>, so you can use the tools.
-If <code>$GOBIN</code> is set, the <a href="/cmd/go">go command</a>
-installs all commands there.
 </p>
 
 <p><code>$GOARM</code> (arm, default=6)</p>
diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 7929a3a54d6..e62de32e160 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -199,8 +199,6 @@ along with their dependencies.
 
 For more about the build flags, see 'go help build'.
 For more about specifying packages, see 'go help packages'.
-For more about where packages and binaries are installed,
-see 'go help gopath'.
 
 See also: go build, go get, go clean.
 	`,
@@ -304,13 +302,20 @@ const (
 )
 
 var (
-	gobin        = os.Getenv("GOBIN")
 	goroot       = filepath.Clean(runtime.GOROOT())
+	gobin        = defaultGobin()
 	gorootSrcPkg = filepath.Join(goroot, "src/pkg")
 	gorootPkg    = filepath.Join(goroot, "pkg")
 	gorootSrc    = filepath.Join(goroot, "src")
 )
 
+func defaultGobin() string {
+	if s := os.Getenv("GOBIN"); s != "" {
+		return s
+	}
+	return filepath.Join(goroot, "bin")
+}
+
 func (b *builder) init() {
 	var err error
 	b.print = fmt.Print
@@ -382,24 +387,18 @@ func goFilesPackage(gofiles []string) *Package {
 	pkg.load(&stk, bp, err)
 	pkg.localPrefix = dirToImportPath(dir)
 	pkg.ImportPath = "command-line-arguments"
-	pkg.target = ""
 
-	if pkg.Name == "main" {
-		_, elem := filepath.Split(gofiles[0])
-		exe := elem[:len(elem)-len(".go")] + exeSuffix
-		if *buildO == "" {
-			*buildO = exe
-		}
-		if gobin != "" {
-			pkg.target = filepath.Join(gobin, exe)
-		}
-	} else {
-		if *buildO == "" {
+	if *buildO == "" {
+		if pkg.Name == "main" {
+			_, elem := filepath.Split(gofiles[0])
+			*buildO = elem[:len(elem)-len(".go")] + exeSuffix
+		} else {
 			*buildO = pkg.Name + ".a"
 		}
 	}
+	pkg.target = ""
+	pkg.Target = ""
 	pkg.Stale = true
-	pkg.Target = pkg.target
 
 	computeStale(pkg)
 	return pkg
@@ -463,13 +462,13 @@ func (b *builder) action(mode buildMode, depMode buildMode, p *Package) *action
 		return a
 	}
 
-	a.link = p.Name == "main"
-	if p.local && (!a.link || p.target == "") {
+	if p.local {
 		// Imported via local path.  No permanent target.
 		mode = modeBuild
 	}
 	a.objdir = filepath.Join(b.work, a.p.ImportPath, "_obj") + string(filepath.Separator)
 	a.objpkg = buildToolchain.pkgpath(b.work, a.p)
+	a.link = p.Name == "main"
 
 	switch mode {
 	case modeInstall:
diff --git a/src/cmd/go/doc.go b/src/cmd/go/doc.go
index aacd7269e62..eb9c38b6396 100644
--- a/src/cmd/go/doc.go
+++ b/src/cmd/go/doc.go
@@ -453,9 +453,7 @@ the final element, not the entire path.  That is, the
 command with source in DIR/src/foo/quux is installed into
 DIR/bin/quux, not DIR/bin/foo/quux.  The foo/ is stripped
 so that you can add DIR/bin to your PATH to get at the
-installed commands.  If the GOBIN environment variable is
-set, commands are installed to the directory it names instead
-of DIR/bin.
+installed commands.
 
 Here's an example directory layout:
 
diff --git a/src/cmd/go/help.go b/src/cmd/go/help.go
index 47ea0c7110f..26640d833c5 100644
--- a/src/cmd/go/help.go
+++ b/src/cmd/go/help.go
@@ -209,9 +209,7 @@ the final element, not the entire path.  That is, the
 command with source in DIR/src/foo/quux is installed into
 DIR/bin/quux, not DIR/bin/foo/quux.  The foo/ is stripped
 so that you can add DIR/bin to your PATH to get at the
-installed commands.  If the GOBIN environment variable is
-set, commands are installed to the directory it names instead
-of DIR/bin.
+installed commands.
 
 Here's an example directory layout:
 
diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index 9a72bb1e2e9..1b6a8c5124c 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -276,9 +276,6 @@ func expandScanner(err error) error {
 // load populates p using information from bp, err, which should
 // be the result of calling build.Context.Import.
 func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package {
-	if gobin != "" {
-		bp.BinDir = gobin
-	}
 	p.copyBuild(bp)
 
 	// The localPrefix is the path we interpret ./ imports relative to.
@@ -541,6 +538,7 @@ func loadPackage(arg string, stk *importStack) *Package {
 		bp, err := build.ImportDir(filepath.Join(gorootSrc, arg), 0)
 		bp.ImportPath = arg
 		bp.Goroot = true
+		bp.BinDir = gobin
 		bp.Root = goroot
 		bp.SrcRoot = gorootSrc
 		p := new(Package)