go/packages/internal/linecount: count lines in Go packages
This CL adds a command to count source lines of Go packages,
with options to filter or group by module, package, or file.
It serves as an example of packages.Load.
Change-Id: Ifeed917b563e91e8425c74783f8992e7b2d25c81
Reviewed-on: https://go-review.googlesource.com/c/tools/+/691937
Auto-Submit: Alan Donovan <adonovan@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Commit-Queue: Alan Donovan <adonovan@google.com>
diff --git a/go/packages/doc.go b/go/packages/doc.go
index f1931d1..366aab6 100644
--- a/go/packages/doc.go
+++ b/go/packages/doc.go
@@ -76,6 +76,8 @@
according to the conventions of the underlying build system.
See the Example function for typical usage.
+See also [golang.org/x/tools/go/packages/internal/linecount]
+for an example application.
# The driver protocol
diff --git a/go/packages/internal/linecount/linecount.go b/go/packages/internal/linecount/linecount.go
new file mode 100644
index 0000000..f1fae38
--- /dev/null
+++ b/go/packages/internal/linecount/linecount.go
@@ -0,0 +1,189 @@
+// Copyright 2025 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 linecount command shows the number of lines of code in a set of
+// Go packages plus their dependencies. It serves as a working
+// illustration of the [packages.Load] operation.
+//
+// Example: show gopls' total source line count, and its breakdown
+// between gopls, x/tools, and the std go/* packages. (The balance
+// comes from other std packages.)
+//
+// $ linecount -mode=total ./gopls
+// 752124
+// $ linecount -mode=total -module=golang.org/x/tools/gopls ./gopls
+// 103519
+// $ linecount -mode=total -module=golang.org/x/tools ./gopls
+// 99504
+// $ linecount -mode=total -prefix=go -module=std ./gopls
+// 47502
+//
+// Example: show the top 5 modules contributing to gopls' source line count:
+//
+// $ linecount -mode=module ./gopls | head -n 5
+// 440274 std
+// 103519 golang.org/x/tools/gopls
+// 99504 golang.org/x/tools
+// 40220 honnef.co/go/tools
+// 17707 golang.org/x/text
+//
+// Example: show the top 3 largest files in the gopls module:
+//
+// $ linecount -mode=file -module=golang.org/x/tools/gopls ./gopls | head -n 3
+// 6841 gopls/internal/protocol/tsprotocol.go
+// 3769 gopls/internal/golang/completion/completion.go
+// 2202 gopls/internal/cache/snapshot.go
+package main
+
+import (
+ "bytes"
+ "cmp"
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "path"
+ "slices"
+ "strings"
+ "sync"
+
+ "golang.org/x/sync/errgroup"
+ "golang.org/x/tools/go/packages"
+)
+
+// TODO(adonovan): filters:
+// - exclude comment and blank lines (-nonblank)
+// - exclude generated files (-generated=false)
+// - exclude non-CompiledGoFiles
+// - include OtherFiles (asm, etc)
+// - include tests (needs care to avoid double counting)
+
+func usage() {
+ // See https://go.dev/issue/63659.
+ fmt.Fprintf(os.Stderr, "Usage: linecount [flags] packages...\n")
+ flag.PrintDefaults()
+ fmt.Fprintf(os.Stderr, `
+Docs: go doc golang.org/x/tools/go/packages/internal/linecount
+https://pkg.go.dev/golang.org/x/tools/go/packages/internal/linecount
+`)
+}
+
+func main() {
+ // Parse command line.
+ log.SetPrefix("linecount: ")
+ log.SetFlags(0)
+ var (
+ mode = flag.String("mode", "file", "group lines by 'module', 'package', or 'file', or show only 'total'")
+ prefix = flag.String("prefix", "", "only count files in packages whose path has the specified prefix")
+ onlyModule = flag.String("module", "", "only count files in the specified module")
+ )
+ flag.Usage = usage
+ flag.Parse()
+ if len(flag.Args()) == 0 {
+ usage()
+ os.Exit(1)
+ }
+
+ // Load packages.
+ cfg := &packages.Config{
+ Mode: packages.NeedName |
+ packages.NeedFiles |
+ packages.NeedImports |
+ packages.NeedDeps |
+ packages.NeedModule,
+ }
+ pkgs, err := packages.Load(cfg, flag.Args()...)
+ if err != nil {
+ log.Fatal(err)
+ }
+ if packages.PrintErrors(pkgs) > 0 {
+ os.Exit(1)
+ }
+
+ // Read files and count lines.
+ var (
+ mu sync.Mutex
+ byFile = make(map[string]int)
+ byPackage = make(map[string]int)
+ byModule = make(map[string]int)
+ )
+ var g errgroup.Group
+ g.SetLimit(20) // file system parallelism level
+ packages.Visit(pkgs, nil, func(p *packages.Package) {
+ pkgpath := p.PkgPath
+ module := "std"
+ if p.Module != nil {
+ module = p.Module.Path
+ }
+ if *prefix != "" && !within(pkgpath, path.Clean(*prefix)) {
+ return
+ }
+ if *onlyModule != "" && module != *onlyModule {
+ return
+ }
+ for _, f := range p.GoFiles {
+ g.Go(func() error {
+ data, err := os.ReadFile(f)
+ if err != nil {
+ return err
+ }
+ n := bytes.Count(data, []byte("\n"))
+
+ mu.Lock()
+ byFile[f] = n
+ byPackage[pkgpath] += n
+ byModule[module] += n
+ mu.Unlock()
+
+ return nil
+ })
+ }
+ })
+ if err := g.Wait(); err != nil {
+ log.Fatal(err)
+ }
+
+ // Display the result.
+ switch *mode {
+ case "file", "package", "module":
+ var m map[string]int
+ switch *mode {
+ case "file":
+ m = byFile
+ case "package":
+ m = byPackage
+ case "module":
+ m = byModule
+ }
+ type item struct {
+ name string
+ count int
+ }
+ var items []item
+ for name, count := range m {
+ items = append(items, item{name, count})
+ }
+ slices.SortFunc(items, func(x, y item) int {
+ return -cmp.Compare(x.count, y.count)
+ })
+ for _, item := range items {
+ fmt.Printf("%d\t%s\n", item.count, item.name)
+ }
+
+ case "total":
+ total := 0
+ for _, n := range byFile {
+ total += n
+ }
+ fmt.Printf("%d\n", total)
+
+ default:
+ log.Fatalf("invalid -mode %q (want file, package, module, or total)", *mode)
+ }
+}
+
+func within(file, dir string) bool {
+ return file == dir ||
+ strings.HasPrefix(file, dir) && file[len(dir)] == os.PathSeparator
+}
