pre compile regex for exclusions

core/targethasher/graph.go

@@ -105,7 +105,15 @@ func EmptyResult() Result {
 func FromProto(ctx context.Context, r *buildpb.QueryResult, workspaceroot string, hashConfig HashConfig) (Result, error) {
 	// always calculate hash for individual files in the main repo.
 	fullHashRepos := set.NewSet(append([]string{""}, hashConfig.FullHashRepos...)...)
-	excludedRegex := set.NewSet(hashConfig.ExcludedFiles...)
+
+	excludedRegex := make([]*regexp.Regexp, 0, len(hashConfig.ExcludedFiles))
+	for _, pattern := range hashConfig.ExcludedFiles {
+		re, err := regexp.Compile(pattern)
+		if err != nil {
+			return EmptyResult(), fmt.Errorf("invalid excluded regex pattern %q: %w", pattern, err)
+		}
+		excludedRegex = append(excludedRegex, re)
+	}
 
 	return fromProto(ctx, r, &diskHashHelper{
 		workspaceroot:   workspaceroot,
@@ -115,7 +123,7 @@ func FromProto(ctx context.Context, r *buildpb.QueryResult, workspaceroot string
 
 // FromProtoNoHash calculates a DAG graph based on a query result. It does not calculate hashes for targets.
 func FromProtoNoHash(ctx context.Context, r *buildpb.QueryResult) (Result, error) {
-	return fromProto(ctx, r, &noOpHasher{}, "", set.NewSet[string](), set.NewSet[string]())
+	return fromProto(ctx, r, &noOpHasher{}, "", set.NewSet[string](), nil)
 }
 
 // for external targets, url and urls attributes could cause non-deterministic hash values,
@@ -264,7 +272,7 @@ func HashExternalTargets(ctx context.Context, r *buildpb.QueryResult, targets ma
 		WorkspaceRoot: workspaceroot,
 		FullHashRepos: fullHashRepos,
 		// we should not exclude anything for external repository rules
-		ExcludedRegex: set.NewSet[string](),
+		ExcludedRegex: nil,
 	}
 	for name, target := range targets {
 		if target.RuleType == ExternalRuleType {
@@ -311,7 +319,7 @@ func GetTopologicalRootsAndIdentifyBuildableRoots(targets map[string]*Target) []
 	return roots
 }
 
-func fromProto(ctx context.Context, r *buildpb.QueryResult, hasher SourceHasher, workspaceroot string, fullHashRepos set.Set[string], excludedRegex set.Set[string]) (Result, error) {
+func fromProto(ctx context.Context, r *buildpb.QueryResult, hasher SourceHasher, workspaceroot string, fullHashRepos set.Set[string], excludedRegex []*regexp.Regexp) (Result, error) {
 	warns := make(map[string]error)
 	// Build target graph with dependencies, but without hash and root information.
 	targets, err := GetInternalTargetsWithoutHashAndRootInfo(ctx, r)
@@ -439,7 +447,7 @@ type HashParam struct {
 	Warns         map[string]error
 	WorkspaceRoot string
 	FullHashRepos set.Set[string]
-	ExcludedRegex set.Set[string]
+	ExcludedRegex []*regexp.Regexp
 }
 
 // HashRecursively calculates hash for all of the target nodes in the target graph and updates Hash property for each
@@ -469,9 +477,7 @@ func HashRecursively(ctx context.Context, p HashParam) ([]byte, error) {
 			target = t
 		} else {
 			// allows @... targets to be excluded even if //external:... doesn't exist.
-			if excluded, err := isExcluded(p.TargetName, p.ExcludedRegex); err != nil {
-				return nil, err
-			} else if excluded {
+			if isExcluded(p.TargetName, p.ExcludedRegex) {
 				p.Targets[p.TargetName] = &Target{
 					Name:            p.TargetName,
 					RuleType:        ExternalRuleType,
@@ -527,9 +533,7 @@ func HashRecursively(ctx context.Context, p HashParam) ([]byte, error) {
 	}
 
 	// excluded, return empty hash.
-	if excluded, err := isExcluded(p.TargetName, p.ExcludedRegex); err != nil {
-		return nil, err
-	} else if excluded {
+	if isExcluded(p.TargetName, p.ExcludedRegex) {
 		p.Targets[p.TargetName].Hash = []byte{}
 		p.Targets[p.TargetName].HashWithoutDeps = []byte{}
 		return []byte{}, nil
@@ -660,15 +664,11 @@ func hasAnyPrefix(t *buildpb.Target, rootRulePrefixes []string) bool {
 	return false
 }
 
-func isExcluded(targetName string, excludedRegex set.Set[string]) (bool, error) {
-	for expr := range excludedRegex.Iter() {
-		match, err := regexp.MatchString(expr, targetName)
-		if err != nil {
-			return false, fmt.Errorf("failed to check if excluded: %q", targetName)
-		}
-		if match {
-			return true, nil
+func isExcluded(targetName string, excludedRegex []*regexp.Regexp) bool {
+	for _, re := range excludedRegex {
+		if re.MatchString(targetName) {
+			return true
 		}
 	}
-	return false, nil
+	return false
 }

core/targethasher/graph_test.go

@@ -6,15 +6,16 @@ import (
 	"io"
 	"os"
 	"path"
+	"regexp"
 	"strings"
 	"testing"
 
 	buildpb "github.com/bazelbuild/buildtools/build_proto"
+	set "github.com/deckarep/golang-set/v2"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	set "github.com/deckarep/golang-set/v2"
 )
 
 func StringPtr(s string) *string {
@@ -84,7 +85,7 @@ func TestContextCancellation(t *testing.T) {
 	qr := &buildpb.QueryResult{
 		Target: []*buildpb.Target{&buildpb.Target{}},
 	}
-	result, err := fromProto(ctx, qr, nil, "", set.NewSet[string](), set.NewSet[string]())
+	result, err := fromProto(ctx, qr, nil, "", set.NewSet[string](), nil)
 	assert.Equal(t, EmptyResult(), result)
 	assert.ErrorIs(t, err, context.Canceled)
 
@@ -99,6 +100,125 @@ func TestContextCancellation(t *testing.T) {
 	assert.ErrorIs(t, err, context.Canceled)
 }
 
+func TestFromProtoSimpleRule(t *testing.T) {
+	qr := &buildpb.QueryResult{
+		Target: []*buildpb.Target{
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//pkg:lib"),
+					RuleClass: StringPtr("go_library"),
+				},
+			},
+		},
+	}
+
+	result, err := fromProto(context.Background(), qr, &noOpHasher{}, "", set.NewSet[string](), nil)
+	require.NoError(t, err)
+
+	assert.Len(t, result.Targets, 1)
+	assert.Len(t, result.TargetNames, 1)
+	assert.Contains(t, result.Targets, "//pkg:lib")
+	assert.True(t, result.Targets["//pkg:lib"].Root)
+	assert.Equal(t, "go_library", result.Targets["//pkg:lib"].RuleType)
+}
+
+func TestFromProtoWithDependencies(t *testing.T) {
+	qr := &buildpb.QueryResult{
+		Target: []*buildpb.Target{
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//pkg:app"),
+					RuleClass: StringPtr("go_binary"),
+					RuleInput: []string{"//pkg:lib"},
+				},
+			},
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//pkg:lib"),
+					RuleClass: StringPtr("go_library"),
+				},
+			},
+		},
+	}
+
+	result, err := fromProto(context.Background(), qr, &noOpHasher{}, "", set.NewSet[string](), nil)
+	require.NoError(t, err)
+
+	assert.Len(t, result.Targets, 2)
+	assert.Len(t, result.TargetNames, 2)
+
+	// app depends on lib, so lib should come first in topological order
+	assert.Equal(t, "//pkg:lib", result.TargetNames[0])
+	assert.Equal(t, "//pkg:app", result.TargetNames[1])
+
+	// only app should be a root (lib is a dependency)
+	assert.True(t, result.Targets["//pkg:app"].Root)
+	assert.False(t, result.Targets["//pkg:lib"].Root)
+}
+
+func TestFromProtoWithExcludedRegex(t *testing.T) {
+	qr := &buildpb.QueryResult{
+		Target: []*buildpb.Target{
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//pkg:app"),
+					RuleClass: StringPtr("go_binary"),
+				},
+			},
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//vendor:lib"),
+					RuleClass: StringPtr("go_library"),
+				},
+			},
+		},
+	}
+
+	// Exclude targets matching "//vendor:.*"
+	excludedRegex := []*regexp.Regexp{regexp.MustCompile("//vendor:.*")}
+
+	result, err := fromProto(context.Background(), qr, &noOpHasher{}, "", set.NewSet[string](), excludedRegex)
+	require.NoError(t, err)
+
+	assert.Len(t, result.Targets, 2)
+	// Excluded target should have empty hash
+	assert.Empty(t, result.Targets["//vendor:lib"].Hash)
+}
+
+func TestFromProtoWithGeneratedFile(t *testing.T) {
+	qr := &buildpb.QueryResult{
+		Target: []*buildpb.Target{
+			{
+				Type: buildpb.Target_RULE.Enum(),
+				Rule: &buildpb.Rule{
+					Name:      StringPtr("//pkg:generator"),
+					RuleClass: StringPtr("genrule"),
+				},
+			},
+			{
+				Type: buildpb.Target_GENERATED_FILE.Enum(),
+				GeneratedFile: &buildpb.GeneratedFile{
+					Name:           StringPtr("//pkg:generated.go"),
+					GeneratingRule: StringPtr("//pkg:generator"),
+				},
+			},
+		},
+	}
+
+	result, err := fromProto(context.Background(), qr, &noOpHasher{}, "", set.NewSet[string](), nil)
+	require.NoError(t, err)
+
+	assert.Len(t, result.Targets, 2)
+	assert.Contains(t, result.Targets, "//pkg:generator")
+	assert.Contains(t, result.Targets, "//pkg:generated.go")
+	assert.Equal(t, GeneratedFileType, result.Targets["//pkg:generated.go"].RuleType)
+}
+
 func Test_RemoveAttrs(t *testing.T) {
 	regularTarget := &buildpb.Target{
 		Type: buildpb.Target_RULE.Enum(),