Export: trimming enhancements

src/BUILD.plz

@@ -7,11 +7,12 @@ go_binary(
         "github.com/thought-machine/please/src/version.PleaseVersion": VERSION,
     },
     visibility = ["PUBLIC"],
+    strip = False,
     deps = [
         "///third_party/go/github.com_thought-machine_go-flags//:go-flags",
         "///third_party/go/go.uber.org_automaxprocs//maxprocs",
-        "//src/audit",
         "//src/assets",
+        "//src/audit",
         "//src/build",
         "//src/cache",
         "//src/clean",
@@ -29,7 +30,6 @@ go_binary(
         "//src/help",
         "//src/metrics",
         "//src/output",
-        "//src/parse",
         "//src/plz",
         "//src/plzinit",
         "//src/process",

src/core/build_label.go

@@ -622,3 +622,15 @@ func (slice BuildLabels) String() string {
 	}
 	return strings.Join(s, ", ")
 }
+
+// LabelSet defines a set of labels implemented using a map.
+type LabelSet map[BuildLabel]struct{}
+
+func (ls LabelSet) Add(l BuildLabel) {
+	ls[l] = struct{}{}
+}
+
+func (ls LabelSet) Contains(l BuildLabel) bool {
+	_, ok := ls[l]
+	return ok
+}

src/core/build_target.go

@@ -416,6 +416,11 @@ func (target *BuildTarget) String() string {
 	return target.Label.String()
 }
 
+// hashBuildTarget returns a mostly unique hash of a BuildTarget by relying on the BuildLabel hash.
+func hashBuildTarget(target *BuildTarget) uint64 {
+	return hashBuildLabel(target.Label)
+}
+
 // TmpDir returns the temporary working directory for this target, eg.
 // //mickey/donald:goofy -> plz-out/tmp/mickey/donald/goofy._build
 // Note the extra subdirectory to keep rules separate from one another, and the .build suffix
@@ -1471,7 +1476,7 @@ func (target *BuildTarget) AllTestTools() []BuildInput {
 	if target.Test.namedTools == nil {
 		return target.Test.tools
 	}
-	return target.allBuildInputs(target.Test.tools, target.Test.namedTools)
+	return target.selectBuildInputs(target.Test.tools, target.Test.namedTools)
 }
 
 // NamedTestTools returns all named test tools
@@ -1487,7 +1492,7 @@ func (target *BuildTarget) AllDebugTools() []BuildInput {
 	if target.Debug.namedTools == nil {
 		return target.Debug.tools
 	}
-	return target.allBuildInputs(target.Debug.tools, target.Debug.namedTools)
+	return target.selectBuildInputs(target.Debug.tools, target.Debug.namedTools)
 }
 
 // AddDatum adds a new item of data to the target.
@@ -1642,21 +1647,39 @@ func (target *BuildTarget) getCommand(state *BuildState, commands map[string]str
 	return highestCommand
 }
 
+// AllBuildInputs returns all the inputs for this target.
+func (target *BuildTarget) AllBuildInputs() []BuildInput {
+	srcs := target.AllSources()
+	data := target.AllData()
+	tools := target.AllTools()
+
+	size := len(srcs) + len(data) + len(tools)
+	inputs := make([]BuildInput, 0, size)
+	inputs = append(inputs, srcs...)
+	inputs = append(inputs, data...)
+	inputs = append(inputs, tools...)
+	return inputs
+}
+
 // AllSources returns all the sources of this rule.
 func (target *BuildTarget) AllSources() []BuildInput {
 	if target.NamedSources == nil {
 		return target.Sources
 	}
-	return target.allBuildInputs(target.Sources, target.NamedSources)
+	return target.selectBuildInputs(target.Sources, target.NamedSources)
 }
 
-func (target *BuildTarget) allBuildInputs(unnamed []BuildInput, named map[string][]BuildInput) []BuildInput {
-	ret := unnamed
+func (target *BuildTarget) selectBuildInputs(unnamed []BuildInput, named map[string][]BuildInput) []BuildInput {
 	keys := make([]string, 0, len(named))
-	for k := range named {
+	size := len(unnamed)
+	for k, vals := range named {
 		keys = append(keys, k)
+		size += len(vals)
 	}
 	sort.Strings(keys)
+
+	ret := make([]BuildInput, 0, size)
+	ret = append(ret, unnamed...)
 	for _, k := range keys {
 		ret = append(ret, named[k]...)
 	}
@@ -1708,7 +1731,7 @@ func (target *BuildTarget) AllData() []BuildInput {
 		return target.Data
 	}
 
-	return target.allBuildInputs(target.Data, target.NamedData)
+	return target.selectBuildInputs(target.Data, target.NamedData)
 }
 
 // AllDebugData returns all the data for debugging this rule.
@@ -1719,7 +1742,7 @@ func (target *BuildTarget) AllDebugData() []BuildInput {
 	if target.Debug.namedData == nil {
 		return target.Debug.data
 	}
-	return target.allBuildInputs(target.Debug.data, target.Debug.namedData)
+	return target.selectBuildInputs(target.Debug.data, target.Debug.namedData)
 }
 
 // DebugData returns unnamed data for debugging this rule.
@@ -1743,7 +1766,7 @@ func (target *BuildTarget) AllTools() []BuildInput {
 	if target.namedTools == nil {
 		return target.Tools
 	}
-	return target.allBuildInputs(target.Tools, target.namedTools)
+	return target.selectBuildInputs(target.Tools, target.namedTools)
 }
 
 // ToolNames returns an ordered list of tool names.

src/core/graph.go

@@ -13,17 +13,6 @@ import (
 	"github.com/thought-machine/please/src/cmap"
 )
 
-type labelSet map[BuildLabel]struct{}
-
-func (ls labelSet) add(l BuildLabel) {
-	ls[l] = struct{}{}
-}
-
-func (ls labelSet) contains(l BuildLabel) bool {
-	_, ok := ls[l]
-	return ok
-}
-
 // A BuildGraph contains all the loaded targets and packages and maintains their
 // relationships, especially reverse dependencies which are calculated here.
 type BuildGraph struct {
@@ -34,8 +23,8 @@ type BuildGraph struct {
 	// Registered subrepos, as a map of their name to their root.
 	subrepos *cmap.Map[string, *Subrepo]
 	// Subincludes that are subincluded by other subincludes
-	subincludeSubincludes map[BuildLabel]labelSet
-	// Use a mutex as a labelSet isn't atomic. We need to guard against inserting as well as mutating the value.
+	subincludeSubincludes map[BuildLabel]LabelSet
+	// Use a mutex as a LabelSet isn't atomic. We need to guard against inserting as well as mutating the value.
 	subincMux sync.Mutex
 }
 
@@ -168,7 +157,7 @@ func NewGraph() *BuildGraph {
 		targets:               cmap.New[BuildLabel, *BuildTarget](cmap.DefaultShardCount, hashBuildLabel),
 		packages:              cmap.New[packageKey, *Package](cmap.DefaultShardCount, hashPackageKey),
 		subrepos:              cmap.New[string, *Subrepo](cmap.SmallShardCount, cmap.XXHash),
-		subincludeSubincludes: map[BuildLabel]labelSet{},
+		subincludeSubincludes: map[BuildLabel]LabelSet{},
 	}
 	return g
 }
@@ -188,19 +177,19 @@ func (graph *BuildGraph) TransitiveSubincludes(l BuildLabel) []BuildLabel {
 	graph.subincMux.Lock()
 	defer graph.subincMux.Unlock()
 
-	incs := labelSet{}
+	incs := LabelSet{}
 	graph.findTransitiveSubincludes(l, incs)
 
 	ls := slices.Collect(maps.Keys(incs))
 	sort.Sort(BuildLabels(ls))
 	return ls
 }
 
-func (graph *BuildGraph) findTransitiveSubincludes(label BuildLabel, includes labelSet) {
-	if includes.contains(label) {
+func (graph *BuildGraph) findTransitiveSubincludes(label BuildLabel, includes LabelSet) {
+	if includes.Contains(label) {
 		return
 	}
-	includes.add(label)
+	includes.Add(label)
 	for l := range graph.subincludeSubincludes[label] {
 		graph.findTransitiveSubincludes(l, includes)
 	}
@@ -212,8 +201,8 @@ func (graph *BuildGraph) RegisterTransitiveSubinclude(from, to BuildLabel) {
 
 	incs, ok := graph.subincludeSubincludes[from]
 	if !ok {
-		incs = labelSet{}
+		incs = LabelSet{}
 		graph.subincludeSubincludes[from] = incs
 	}
-	incs.add(to)
+	incs.Add(to)
 }

src/core/package.go

@@ -34,23 +34,46 @@ type Package struct {
 	targets map[string]*BuildTarget
 	// Set of output files from rules.
 	Outputs map[string]*BuildTarget
+	// Includes metadata from parsing the package BUILD file.
+	Metadata PackageMetadata
 	// Protects access to above
 	mutex sync.RWMutex
 }
 
-// NewPackage constructs a new package with the given name.
-func NewPackage(name string) *Package {
-	return NewPackageSubrepo(name, "")
+// PackageOptions is a functional option type for configuring a new Package.
+type PackageOptions func(*Package)
+
+// WithPackageSubrepo returns a PackageOptions that sets the subrepo name for a new Package.
+func WithPackageSubrepo(name string) PackageOptions {
+	return func(p *Package) {
+		p.SubrepoName = name
+	}
 }
 
-// NewPackageSubrepo constructs a new package with the given name and subrepo.
-func NewPackageSubrepo(name, subrepo string) *Package {
-	return &Package{
-		Name:        name,
-		SubrepoName: subrepo,
-		targets:     map[string]*BuildTarget{},
-		Outputs:     map[string]*BuildTarget{},
+// WithPackageMetadata returns a PackageOptions that enables tracking of
+// metadata (like statement positions and subinclude mappings) for the Package.
+// This is required for features like 'plz export'.
+func WithPackageMetadata() PackageOptions {
+	return func(p *Package) {
+		p.Metadata = newPackageMetadata()
+	}
+}
+
+// NewPackage constructs a new package with the given name, and enables additional features
+// given the PackageOptions provided.
+func NewPackage(name string, options ...PackageOptions) *Package {
+	pkg := &Package{
+		Name:    name,
+		targets: map[string]*BuildTarget{},
+		Outputs: map[string]*BuildTarget{},
+		// Defaults to noop to avoid storing metadata for most operations
+		Metadata: newNoopPackageMetadata(),
+	}
+
+	for _, option := range options {
+		option(pkg)
 	}
+	return pkg
 }
 
 // Target returns the target with the given name, or nil if this package doesn't have one.
@@ -105,11 +128,11 @@ func (pkg *Package) RegisterSubinclude(label BuildLabel) {
 
 // AllSubincludes returns the full set of subincludes needed for this package, including transitive subincludes
 func (pkg *Package) AllSubincludes(graph *BuildGraph) []BuildLabel {
-	includes := make(labelSet, len(pkg.Subincludes))
+	includes := make(LabelSet, len(pkg.Subincludes))
 
 	for _, s := range pkg.Subincludes {
 		for _, inc := range append(graph.TransitiveSubincludes(s), s) {
-			includes.add(inc)
+			includes.Add(inc)
 		}
 	}