// Copyright 2018 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. // The gopackages command is a diagnostic tool that demonstrates // how to use golang.org/x/tools/go/packages to load, parse, // type-check, and print one or more Go packages. // Its precise output is unspecified and may change. package main import ( "context" "encoding/json" "flag" "fmt" "go/types" "os" "sort" "strings" "golang.org/x/tools/go/packages" "golang.org/x/tools/go/types/typeutil" "golang.org/x/tools/internal/tool" ) func main() { tool.Main(context.Background(), &application{Mode: "imports"}, os.Args[1:]) } type application struct { // Embed the basic profiling flags supported by the tool package tool.Profile Deps bool `flag:"deps" help:"show dependencies too"` Test bool `flag:"test" help:"include any tests implied by the patterns"` Mode string `flag:"mode" help:"mode (one of files, imports, types, syntax, allsyntax)"` Private bool `flag:"private" help:"show non-exported declarations too (if -mode=syntax)"` PrintJSON bool `flag:"json" help:"print package in JSON form"` BuildFlags stringListValue `flag:"buildflag" help:"pass argument to underlying build system (may be repeated)"` } // Name implements tool.Application returning the binary name. func (app *application) Name() string { return "gopackages" } // Usage implements tool.Application returning empty extra argument usage. func (app *application) Usage() string { return "package..." } // ShortHelp implements tool.Application returning the main binary help. func (app *application) ShortHelp() string { return "gopackages loads, parses, type-checks, and prints one or more Go packages." } // DetailedHelp implements tool.Application returning the main binary help. func (app *application) DetailedHelp(f *flag.FlagSet) { fmt.Fprint(f.Output(), ` Packages are specified using the notation of "go list", or other underlying build system. The mode flag determines how much information is computed and printed for the specified packages. In order of increasing computational cost, the legal values are: -mode=files shows only the names of the packages' files. -mode=imports also shows the imports. (This is the default.) -mode=types loads the compiler's export data and displays the type of each exported declaration. -mode=syntax parses and type checks syntax trees for the initial packages. (With the -private flag, the types of non-exported declarations are shown too.) Type information for dependencies is obtained from compiler export data. -mode=allsyntax is like -mode=syntax but applied to all dependencies. Flags: `) f.PrintDefaults() } // Run takes the args after flag processing and performs the specified query. func (app *application) Run(ctx context.Context, args ...string) error { if len(args) == 0 { return tool.CommandLineErrorf("not enough arguments") } // Load, parse, and type-check the packages named on the command line. cfg := &packages.Config{ Mode: packages.LoadSyntax, Tests: app.Test, BuildFlags: app.BuildFlags, } // -mode flag switch strings.ToLower(app.Mode) { case "files": cfg.Mode = packages.LoadFiles case "imports": cfg.Mode = packages.LoadImports case "types": cfg.Mode = packages.LoadTypes case "syntax": cfg.Mode = packages.LoadSyntax case "allsyntax": cfg.Mode = packages.LoadAllSyntax default: return tool.CommandLineErrorf("invalid mode: %s", app.Mode) } cfg.Mode |= packages.NeedModule lpkgs, err := packages.Load(cfg, args...) if err != nil { return err } // -deps: print dependencies too. if app.Deps { // We can't use packages.All because // we need an ordered traversal. var all []*packages.Package // postorder seen := make(map[*packages.Package]bool) var visit func(*packages.Package) visit = func(lpkg *packages.Package) { if !seen[lpkg] { seen[lpkg] = true // visit imports var importPaths []string for path := range lpkg.Imports { importPaths = append(importPaths, path) } sort.Strings(importPaths) // for determinism for _, path := range importPaths { visit(lpkg.Imports[path]) } all = append(all, lpkg) } } for _, lpkg := range lpkgs { visit(lpkg) } lpkgs = all } for _, lpkg := range lpkgs { app.print(lpkg) } return nil } func (app *application) print(lpkg *packages.Package) { if app.PrintJSON { data, _ := json.MarshalIndent(lpkg, "", "\t") os.Stdout.Write(data) return } // title var kind string // TODO(matloob): If IsTest is added back print "test command" or // "test package" for packages with IsTest == true. if lpkg.Name == "main" { kind += "command" } else { kind += "package" } fmt.Printf("Go %s %q:\n", kind, lpkg.ID) // unique ID if mod := lpkg.Module; mod != nil { fmt.Printf("\tmodule %s@%s\n", mod.Path, mod.Version) } fmt.Printf("\tpackage %s\n", lpkg.Name) // characterize type info if lpkg.Types == nil { fmt.Printf("\thas no exported type info\n") } else if !lpkg.Types.Complete() { fmt.Printf("\thas incomplete exported type info\n") } else if len(lpkg.Syntax) == 0 { fmt.Printf("\thas complete exported type info\n") } else { fmt.Printf("\thas complete exported type info and typed ASTs\n") } if lpkg.Types != nil && lpkg.IllTyped && len(lpkg.Errors) == 0 { fmt.Printf("\thas an error among its dependencies\n") } // source files for _, src := range lpkg.GoFiles { fmt.Printf("\tfile %s\n", src) } // imports var lines []string for importPath, imp := range lpkg.Imports { var line string if imp.ID == importPath { line = fmt.Sprintf("\timport %q", importPath) } else { line = fmt.Sprintf("\timport %q => %q", importPath, imp.ID) } lines = append(lines, line) } sort.Strings(lines) for _, line := range lines { fmt.Println(line) } // errors for _, err := range lpkg.Errors { fmt.Printf("\t%s\n", err) } // types of package members if lpkg.Types != nil { qual := types.RelativeTo(lpkg.Types) scope := lpkg.Types.Scope() for _, name := range scope.Names() { obj := scope.Lookup(name) if !obj.Exported() && !app.Private { continue // skip unexported names } fmt.Printf("\t%s\n", types.ObjectString(obj, qual)) if _, ok := obj.(*types.TypeName); ok { for _, meth := range typeutil.IntuitiveMethodSet(obj.Type(), nil) { if !meth.Obj().Exported() && !app.Private { continue // skip unexported names } fmt.Printf("\t%s\n", types.SelectionString(meth, qual)) } } } } fmt.Println() } // stringListValue is a flag.Value that accumulates strings. // e.g. --flag=one --flag=two would produce []string{"one", "two"}. type stringListValue []string func newStringListValue(val []string, p *[]string) *stringListValue { *p = val return (*stringListValue)(p) } func (ss *stringListValue) Get() interface{} { return []string(*ss) } func (ss *stringListValue) String() string { return fmt.Sprintf("%q", *ss) } func (ss *stringListValue) Set(s string) error { *ss = append(*ss, s); return nil }