code review 5495055: go: implement test command

src/cmd/go/build.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"
         "fmt"
         "go/build"
@@ skipping 87 matching lines @@
 
 // A builder holds global state about a build.
 // It does not hold per-package state, because eventually we will
 // build packages in parallel, and the builder will be shared.
 type builder struct {
         work        string               // the temporary work directory (ends in filepath.Separator)
         aflag       bool                 // the -a flag
         nflag       bool                 // the -n flag
         vflag       bool                 // the -v flag
         arch        string               // e.g., "6"
+        goroot      string               // the $GOROOT
         actionCache map[cacheKey]*action // a cache of already-constructed actions
 }
 
 // An action represents a single action in the action graph.
 type action struct {
         f func(*builder, *action) error // the action itself
 
-        p      *Package  // the package this action works on
-        deps   []*action // actions that must happen before this one
-        done   bool      // whether the action is done (might have failed)
-        failed bool      // whether the action failed
+        p          *Package  // the package this action works on
+        deps       []*action // actions that must happen before this one
+        done       bool      // whether the action is done (might have failed)
+        failed     bool      // whether the action failed
+        pkgdir     string    // the -I or -L argument to use when importing this package
+        ignoreFail bool      // whether to run f even if dependencies fail
 
         // Results left for communication with other code.
         pkgobj string // the built .a file
         pkgbin string // the built a.out file, if one exists
 }
 
 // cacheKey is the key for the action cache.
 type cacheKey struct {
         mode buildMode
         p    *Package
 }
 
 // buildMode specifies the build mode:
 // are we just building things or also installing the results?
 type buildMode int
 
 const (
         modeBuild buildMode = iota
         modeInstall
 )
 
 func (b *builder) init(aflag, nflag, vflag bool) {
         var err error
         b.aflag = aflag
         b.nflag = nflag
         b.vflag = vflag
         b.actionCache = make(map[cacheKey]*action)
+        b.goroot = runtime.GOROOT()
 
         b.arch, err = build.ArchChar(build.DefaultContext.GOARCH)
         if err != nil {
                 fatalf("%s", err)
         }
 
         if nflag {
                 b.work = "$WORK"
         } else {
                 b.work, err = ioutil.TempDir("", "go-build")
@@ skipping 46 matching lines @@
 
 // action returns the action for applying the given operation (mode) to the package.
 // depMode is the action to use when building dependencies.
 func (b *builder) action(mode buildMode, depMode buildMode, p *Package) *action {
         key := cacheKey{mode, p}
         a := b.actionCache[key]
         if a != nil {
                 return a
         }
 
-        a = &action{p: p}
+        a = &action{p: p, pkgdir: p.t.PkgDir()}
+        if p.pkgdir != "" { // overrides p.t
+                a.pkgdir = p.pkgdir
+        }
+
         b.actionCache[key] = a
 
         switch mode {
         case modeBuild, modeInstall:
+                for _, p1 := range p.imports {
+                        a.deps = append(a.deps, b.action(depMode, depMode, p1))
+                }
+
                 if !needInstall(p) && !b.aflag {
+                        // TODO: This is not right if the deps above
+                        // are not all no-ops too.  If fmt is up to date
+                        // wrt its own source files,  but strconv has
+                        // changed, then fmt is not up to date.
                         a.f = (*builder).nop
                         return a
                 }
                 if p.Standard {
                         switch p.ImportPath {
                         case "runtime", "runtime/cgo":
                                 // Too complex - can't build.
                                 a.f = (*builder).nop
                                 return a
                         case "builtin", "unsafe":
                                 // Fake packages - nothing to build.
                                 a.f = (*builder).nop
                                 return a
                         }
                 }
 
                 if mode == modeInstall {
                         a.f = (*builder).install
                         a.deps = []*action{b.action(modeBuild, depMode, p)}
                         return a
                 }
 
                 a.f = (*builder).build
-                for _, p1 := range p.imports {
-                        a.deps = append(a.deps, b.action(depMode, depMode, p1))
-                }
         }
 
         return a
 }
 
 // needInstall reports whether p needs to be built and installed.
 // That is only true if some source file is newer than the installed package binary.
 func needInstall(p *Package) bool {
         if p.targ == "" {
                 return true
@@ skipping 27 matching lines @@
 
 // do runs the action graph rooted at a.
 func (b *builder) do(a *action) {
         if a.done {
                 return
         }
         for _, a1 := range a.deps {
                 b.do(a1)
                 if a1.failed {
                         a.failed = true
-                        a.done = true
-                        return
+                        if !a.ignoreFail {
+                                a.done = true
+                                return
+                        }
                 }
         }
         if err := a.f(b, a); err != nil {
                 errorf("%s", err)
                 a.failed = true
         }
         a.done = true
 }
 
 func (b *builder) nop(a *action) error {
         return nil
 }
 
-// build is the action for building a single package.
+// build is the action for building a single package or command.
 func (b *builder) build(a *action) error {
         obj := filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+"/_obj")) + string(filepath.Separator)
-        a.pkgobj = filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+".a"))
+        if a.pkgobj == "" {
+                a.pkgobj = filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+".a"))
+        }
 
         // make build directory
         if err := b.mkdir(obj); err != nil {
                 return err
         }
 
         var objects []string
         var gofiles []string
         gofiles = append(gofiles, a.p.GoFiles...)
 
         // run cgo
         if len(a.p.CgoFiles) > 0 {
                 outGo, outObj, err := b.cgo(a.p.Dir, obj, a.p.info)
                 if err != nil {
                         return err
                 }
                 objects = append(objects, outObj...)
                 gofiles = append(gofiles, outGo...)
         }
 
         // prepare Go import path list
         var inc []string
         inc = append(inc, "-I", b.work)
         incMap := map[string]bool{}
         for _, a1 := range a.deps {
-                p1 := a1.p
-                if p1.t.Goroot {
+                pkgdir := a1.pkgdir
+                if pkgdir == build.Path[0].PkgDir() || pkgdir == "" {
                         continue
                 }
-                pkgdir := p1.t.PkgDir()
                 if !incMap[pkgdir] {
                         incMap[pkgdir] = true
                         inc = append(inc, "-I", pkgdir)
                 }
         }
 
         // compile Go
         if len(gofiles) > 0 {
                 out := "_go_.6"
                 if err := b.gc(a.p.Dir, obj+out, a.p.ImportPath, inc, gofiles); err != nil {
@@ skipping 29 matching lines @@
                 if err := b.ld(a.p.Dir, a.pkgbin, inc, a.pkgobj); err != nil {
                         return err
                 }
         }
 
         return nil
 }
 
 // install is the action for installing a single package.
 func (b *builder) install(a *action) error {
-        if err := b.build(a); err != nil {
-                return err
-        }
-
+        a1 := a.deps[0]
         var src string
         var perm uint32
-        if a.pkgbin != "" {
-                src = a.pkgbin
+        if a1.pkgbin != "" {
+                src = a1.pkgbin
                 perm = 0777
         } else {
-                src = a.pkgobj
+                src = a1.pkgobj
                 perm = 0666
         }
 
         // make target directory
         dst := a.p.targ
         dir, _ := filepath.Split(dst)
         if dir != "" {
                 if err := b.mkdir(dir); err != nil {
                         return err
                 }
@@ skipping 203 matching lines @@
 
         // cc _cgo_import.ARCH
         importObj := obj + "_cgo_import." + b.arch
         if err := b.cc(dir, importObj, importC); err != nil {
                 return nil, nil, err
         }
         outObj = append(outObj, importObj)
 
         return outGo, outObj, nil
 }