code review 5708054: cmd/go: fixes

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 (
         "bytes"
         "errors"
         "fmt"
@@ skipping 143 matching lines @@
 // not to use the package cache.
 func reloadPackage(arg string, stk *importStack) *Package {
         p := packageCache[arg]
         if p != nil {
                 delete(packageCache, p.Dir)
                 delete(packageCache, p.ImportPath)
         }
         return loadPackage(arg, stk)
 }
 
-// loadImport scans directory named by arg, which must be an import path,
+// loadImport scans the directory named by path, which must be an import path,
 // but possibly a local import path (an absolute file system path or one beginning
 // with ./ or ../).  A local relative path is interpreted relative to srcDir.
 // It returns a *Package describing the package found in that directory.
 func loadImport(path string, srcDir string, stk *importStack, importPos []token.Position) *Package {
         stk.push(path)
         defer stk.pop()
 
         // Determine canonical identifier for this package.
         // For a local path (./ or ../) the identifier is the full
         // directory name.  Otherwise it is the import path.
@@ skipping 129 matching lines @@
         if len(p.CgoFiles) > 0 && (!p.Standard || p.ImportPath != "runtime/cgo") {
                 importPaths = append(importPaths, "runtime/cgo")
         }
         // Everything depends on runtime, except runtime and unsafe.
         if !p.Standard || (p.ImportPath != "runtime" && p.ImportPath != "unsafe") {
                 importPaths = append(importPaths, "runtime")
         }
 
         // Build list of full paths to all Go files in the package,
         // for use by commands like go fmt.
-        for _, f := range p.GoFiles {
-                p.gofiles = append(p.gofiles, filepath.Join(p.Dir, f))
-        }
-        for _, f := range p.CgoFiles {
-                p.gofiles = append(p.gofiles, filepath.Join(p.Dir, f))
-        }
-        for _, f := range p.TestGoFiles {
-                p.gofiles = append(p.gofiles, filepath.Join(p.Dir, f))
-        }
-        for _, f := range p.XTestGoFiles {
-                p.gofiles = append(p.gofiles, filepath.Join(p.Dir, f))
+        p.gofiles = stringList(p.GoFiles, p.CgoFiles, p.TestGoFiles, p.XTestGoFiles)
+        for i := range p.gofiles {
+                p.gofiles[i] = filepath.Join(p.Dir, p.gofiles[i])
         }
         sort.Strings(p.gofiles)
 
         // Build list of imported packages and full dependency list.
         imports := make([]*Package, 0, len(p.Imports))
         deps := make(map[string]bool)
         for i, path := range importPaths {
                 if path == "C" {
                         continue
                 }
                 p1 := loadImport(path, p.Dir, stk, p.build.ImportPos[path])
                 if p1.local {
                         path = p1.Dir
                         importPaths[i] = path
-                }
-                if build.IsLocalImport(path) {
-                        println("LOCAL?", p.Dir, p1, p1.local, p1.Dir, p1.ImportPath, path)
                 }
                 deps[path] = true
                 imports = append(imports, p1)
                 for _, dep := range p1.Deps {
                         deps[dep] = true
                 }
                 if p1.Incomplete {
                         p.Incomplete = true
                 }
         }
@@ skipping 52 matching lines @@
         topRoot := map[string]bool{}
         for _, p := range pkgs {
                 topRoot[p.Root] = true
         }
 
         for _, p := range packageList(pkgs) {
                 p.Stale = isStale(p, topRoot)
         }
 }
 
+// isStale reports whether package p needs to be rebuilt.
 func isStale(p *Package, topRoot map[string]bool) bool {
         if p.Standard && p.ImportPath == "unsafe" {
-                // fake package
+                // fake, builtin package
                 return false
         }
         if p.Error != nil {
                 return true
         }
 
         // A package without Go sources means we only found
         // the installed .a file.  Since we don't know how to rebuild
         // it, it can't be stale, even if -a is set.  This enables binary-only
         // distributions of Go packages, although such binaries are
@@ skipping 48 matching lines @@
         // package named on the command-line, assume it is up-to-date
         // no matter what the modification times on the source files indicate.
         // This avoids rebuilding $GOROOT packages when people are
         // working outside the Go root, and it effectively makes each tree
         // listed in $GOPATH a separate compilation world.
         // See issue 3149.
         if p.Root != "" && !topRoot[p.Root] {
                 return false
         }
 
-        srcss := [][]string{
-                p.GoFiles,
-                p.CFiles,
-                p.HFiles,
-                p.SFiles,
-                p.CgoFiles,
-        }
-
-        for _, srcs := range srcss {
-                for _, src := range srcs {
-                        if olderThan(filepath.Join(p.Dir, src)) {
-                                return true
-                        }
+        srcs := stringList(p.GoFiles, p.CFiles, p.HFiles, p.SFiles, p.CgoFiles)
+        for _, src := range srcs {
+                if olderThan(filepath.Join(p.Dir, src)) {
+                        return true
                 }
         }
 
         return false
 }
 
 var cwd, _ = os.Getwd()
 
 var cmdCache = map[string]*Package{}
 
@@ skipping 135 matching lines @@
         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
 }