diff --git a/vendor/cmd/go/internal/deplist/deplist.go b/vendor/cmd/go/internal/deplist/deplist.go new file mode 100644 index 0000000..023ecfe --- /dev/null +++ b/vendor/cmd/go/internal/deplist/deplist.go @@ -0,0 +1,100 @@ +// 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 deplist implements the ``go deplist'' command. +package deplist + +import ( + "cmd/go/internal/base" + "cmd/go/internal/load" + "cmd/go/internal/work" +) + +var CmdDeplist = &base.Command{ + Run: runDeplist, + CustomFlags: true, + UsageLine: "deplist [-n] [-x] [build flags] [deplist flags] [packages]", + Short: "provide JSON package build information for dependencies of packages", + Long: ` +Deplist provide JSON package build information for dependencies of packages + `, +} + +func runDeplist(cmd *base.Command, args []string) { + deplistFlags, pkgArgs := deplistFlags(args) + + work.BuildInit() + + test := false + build := false + + for _, v := range deplistFlags { + switch v { + case "-test": + test = true + case "-build": + build = true + } + } + + if !build { + base.Fatalf("don't yet know what to do without -build flag") + } + + deps := make(map[string]bool) + var testDeps []string + + pkgs := load.PackagesAndErrors(pkgArgs) + if len(pkgs) == 0 { + base.Fatalf("no packages to deplist") + } + + for _, p := range pkgs { + for _, d := range p.Deps { + deps[d] = true + } + + if test { + for _, d := range p.TestImports { + testDeps = append(testDeps, d) + } + for _, d := range p.XTestImports { + testDeps = append(testDeps, d) + } + } + } + + var testPkgArgs []string + + for _, d := range testDeps { + if !deps[d] { + testPkgArgs = append(testPkgArgs, d) + } + } + + if len(testPkgArgs) > 0 { + for _, p := range load.PackagesAndErrors(testPkgArgs) { + deps[p.ImportPath] = true + for _, d := range p.Deps { + deps[d] = true + } + } + } + + var uniqDeps []string + for p := range deps { + uniqDeps = append(uniqDeps, p) + } + + depPkgs := load.PackagesForBuild(uniqDeps) + + var b work.Builder + b.Init() + + root := &work.Action{Mode: "go deplist"} + for _, p := range depPkgs { + root.Deps = append(root.Deps, b.DeplistAction(work.ModeBuild, work.ModeBuild, p)) + } + b.Do(root) +} diff --git a/vendor/cmd/go/internal/deplist/deplistFlag.go b/vendor/cmd/go/internal/deplist/deplistFlag.go new file mode 100644 index 0000000..b3d73ff --- /dev/null +++ b/vendor/cmd/go/internal/deplist/deplistFlag.go @@ -0,0 +1,64 @@ +// Copyright 2017 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 deplist + +import ( + "flag" + "fmt" + "os" + "strings" + + "cmd/go/internal/base" + "cmd/go/internal/cmdflag" + "cmd/go/internal/work" +) + +const cmd = "deplist" + +// deplistFlagDefn is the set of flags we process. +var deplistFlagDefn = []*cmdflag.Defn{ + {Name: "test", BoolVar: new(bool)}, + {Name: "build", BoolVar: new(bool)}, +} + +var deplistTool string + +// add build flags to deplistFlagDefn. +func init() { + var cmd base.Command + work.AddBuildFlags(&cmd) + cmd.Flag.VisitAll(func(f *flag.Flag) { + deplistFlagDefn = append(deplistFlagDefn, &cmdflag.Defn{ + Name: f.Name, + Value: f.Value, + }) + }) +} + +// deplistFlags processes the command line, splitting it at the first non-flag +// into the list of flags and list of packages. +func deplistFlags(args []string) (passToDeplist, packageNames []string) { + for i := 0; i < len(args); i++ { + if !strings.HasPrefix(args[i], "-") { + return args[:i], args[i:] + } + + f, value, extraWord := cmdflag.Parse(cmd, deplistFlagDefn, args, i) + if f == nil { + fmt.Fprintf(os.Stderr, "deplist: flag %q not defined\n", args[i]) + fmt.Fprintf(os.Stderr, "Run \"go help deplist\" for more information\n") + os.Exit(2) + } + if f.Value != nil { + if err := f.Value.Set(value); err != nil { + base.Fatalf("invalid flag argument for -%s: %v", f.Name, err) + } + } + if extraWord { + i++ + } + } + return args, nil +} diff --git a/vendor/cmd/go/internal/work/action.go b/vendor/cmd/go/internal/work/action.go index 9f1f8f8..abc4c57 100644 --- a/vendor/cmd/go/internal/work/action.go +++ b/vendor/cmd/go/internal/work/action.go @@ -403,6 +403,32 @@ func (b *Builder) VetAction(mode, depMode BuildMode, p *load.Package) *Action { return a } +// DeplistAction returns the action for running go deplist on package p. +// It depends on the action for compiling p. +// If the caller may be causing p to be installed, it is up to the caller +// to make sure that the install depends on (runs after) deplist. +func (b *Builder) DeplistAction(mode, depMode BuildMode, p *load.Package) *Action { + // Construct deplist action. + a := b.cacheAction("deplist", p, func() *Action { + a1 := b.CompileAction(mode, depMode, p) + + a := &Action{ + Mode: "deplist", + Package: p, + Deps: []*Action{a1}, + Objdir: a1.Objdir, + } + if a1.Func == nil { + // Built-in packages like unsafe. + return a + } + a.Func = (*Builder).deplist + + return a + }) + return a +} + // LinkAction returns the action for linking p into an executable // and possibly installing the result (according to mode). // depMode is the action (build or install) to use when compiling dependencies. diff --git a/vendor/cmd/go/internal/work/exec.go b/vendor/cmd/go/internal/work/exec.go index a1d68d2..7750836 100644 --- a/vendor/cmd/go/internal/work/exec.go +++ b/vendor/cmd/go/internal/work/exec.go @@ -761,6 +761,43 @@ func (b *Builder) vet(a *Action) error { return b.run(a, p.Dir, p.ImportPath, env, cfg.BuildToolexec, tool, VetFlags, a.Objdir+"vet.cfg") } +func (b *Builder) deplist(a *Action) error { + // a.Deps[0] is the build of the package being deplistted. + + p := a.Deps[0].Package + + enc := json.NewEncoder(os.Stdout) + enc.SetIndent("", "\t") + + failed := false + + c := cache.Default() + ca, err := c.Get(a.Deps[0].actionID) + if err != nil { + failed = true + } + + details := struct { + ImportPath string + PackageFile string + Incomplete bool + }{ + ImportPath: p.ImportPath, + } + + if !failed { + details.PackageFile = c.OutputFile(ca.OutputID) + } else { + details.Incomplete = true + } + + if err := enc.Encode(details); err != nil { + return fmt.Errorf("failed to JSON encode package: %v", err) + } + + return nil +} + // linkActionID computes the action ID for a link action. func (b *Builder) linkActionID(a *Action) cache.ActionID { p := a.Package diff --git a/vendor/cmd/go/main.go b/vendor/cmd/go/main.go index c5a6df4..6d3e120 100644 --- a/vendor/cmd/go/main.go +++ b/vendor/cmd/go/main.go @@ -19,6 +19,7 @@ import ( "cmd/go/internal/bug" "cmd/go/internal/cfg" "cmd/go/internal/clean" + "cmd/go/internal/deplist" "cmd/go/internal/doc" "cmd/go/internal/envcmd" "cmd/go/internal/fix" @@ -56,6 +57,7 @@ func init() { vgo.CmdVerify, version.CmdVersion, vet.CmdVet, + deplist.CmdDeplist, help.HelpBuildmode, help.HelpC,