code review 5595044: cmd/go: add go tools to rearrangement

src/cmd/go/pkg.go

 // Copyright 2011 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 main
 
 import (
         "go/build"
         "os"
         "path/filepath"
@@ skipping 206 matching lines @@
                                 b = append(b, ' ')
                         }
                 default:
                         space = false
                         b = append(b, c)
                 }
         }
         return string(b)
 }
 
+// isGoTool is the list of directories for Go programs that are installed in
+// $GOROOT/bin/go-tool.
 var isGoTool = map[string]bool{
-        "fix":  true,
-        "vet":  true,
-        "yacc": true,
+        "cmd/fix":  true,
+        "cmd/vet":  true,
+        "cmd/yacc": true,
 }
 
 func scanPackage(ctxt *build.Context, t *build.Tree, arg, importPath, dir string, stk *importStack) *Package {
         // Read the files in the directory to learn the structure
         // of the package.
         p := &Package{
                 ImportPath: importPath,
                 Dir:        dir,
                 Standard:   t.Goroot && !strings.Contains(importPath, "."),
                 t:          t,
@@ skipping 20 matching lines @@
         p.XTestGoFiles = info.XTestGoFiles
         p.CFiles = info.CFiles
         p.HFiles = info.HFiles
         p.SFiles = info.SFiles
         p.CgoFiles = info.CgoFiles
         p.CgoCFLAGS = info.CgoCFLAGS
         p.CgoLDFLAGS = info.CgoLDFLAGS
 
         if info.Package == "main" {
                 _, elem := filepath.Split(importPath)
-                if t.Goroot && isGoTool[elem] {

[rsc, 2012/01/29 18:51:11]

I am a little worried about people hitting this accidentally.
How about instead

if t.Goroot && isGoTool[p.ImportPath] {

and then the map above would need entries like cmd/fix cmd/vet cmd/yacc.

+                if t.Goroot && isGoTool[p.ImportPath] {
                         p.target = filepath.Join(t.Path, "bin/go-tool", elem)
                 } else {
                         p.target = filepath.Join(t.BinDir(), elem)
                 }
                 if ctxt.GOOS == "windows" {
                         p.target += ".exe"
                 }
         } else {
                 p.target = filepath.Join(t.PkgDir(), filepath.FromSlash(importPath)+".a")
         }
@@ skipping 128 matching lines @@
 // to load dependencies of a named package, the named
 // package is still returned, with p.Incomplete = true
 // and details in p.DepsErrors.
 func packages(args []string) []*Package {
         args = importPaths(args)
         var pkgs []*Package
         var stk importStack
         for _, arg := range args {
                 pkg := loadPackage(arg, &stk)
                 if pkg.Error != nil {
-                        errorf("%s", pkg.Error)
+                        errorf("can't load package: %s", pkg.Error)
                         continue
                 }
                 pkgs = append(pkgs, pkg)
         }
         return pkgs
 }
 
 // packagesAndErrors is like 'packages' but returns a·
 // *Package for every argument, even the ones that
 // cannot be loaded at all.
 // The packages that fail to load will have p.Error != nil.
 func packagesAndErrors(args []string) []*Package {
         args = importPaths(args)
         var pkgs []*Package
         var stk importStack
         for _, arg := range args {
                 pkgs = append(pkgs, loadPackage(arg, &stk))
         }
         return pkgs
 }
 
 // packagesForBuild is like 'packages' but fails if any of
 // the packages or their dependencies have errors
 // (cannot be built).
 func packagesForBuild(args []string) []*Package {
         pkgs := packagesAndErrors(args)
         printed := map[*PackageError]bool{}
         for _, pkg := range pkgs {
                 if pkg.Error != nil {
-                        errorf("%s", pkg.Error)
+                        errorf("can't load package: %s", pkg.Error)
                 }
                 for _, err := range pkg.DepsErrors {
                         // Since these are errors in dependencies,
                         // the same error might show up multiple times,
                         // once in each package that depends on it.
                         // Only print each once.
                         if !printed[err] {
                                 printed[err] = true
                                 errorf("%s", err)
                         }
                 }
         }
         exitIfErrors()
         return pkgs
 }