fix: Preventing parse errors in stack generation in worktrees

Right now, users with negations in their filter expressions aren't
preventing reading parsing from happening in worktrees during stack
generation. This is because we aren't properly propagating the non-Git
filters from the parent discovery down to child discoveries.

This fix this by properly propagating the non-Git filters from the
parent discovery down to child discoveries.

Author: yhakbar

internal/discovery/phase_worktree.go

@@ -196,8 +196,14 @@ func (p *WorktreePhase) discoverInWorktree(
 		return nil, err
 	}
 
+	// Propagate non-git filters from the parent discovery to the worktree sub-discovery.
+	// Git expressions are excluded to avoid infinite recursion (the worktree phase is
+	// already handling them). All other filters (path, attribute, negation) are included
+	// so that exclusions and type constraints apply within sub-discoveries.
+	allFilters := append(filters, discovery.filters.ExcludingGitFilters()...)
+
 	subDiscovery := NewDiscovery(wt.Path).
-		WithFilters(filters).
+		WithFilters(allFilters).
 		WithDiscoveryContext(discoveryContext).
 		WithNumWorkers(p.numWorkers)
 
@@ -312,10 +318,12 @@ func (p *WorktreePhase) walkChangedStack(
 		errs = make([]error, 0, 2) //nolint:mnd
 	)
 
+	parentFilters := discovery.filters.ExcludingGitFilters()
+
 	discoveryGroup.Go(func() error {
 		fromDiscovery := NewDiscovery(fromStack.Path()).
 			WithDiscoveryContext(fromDiscoveryContext).
-			WithFilters(filter.Filters{}).
+			WithFilters(parentFilters).
 			WithNumWorkers(p.numWorkers)
 
 		var fromDiscoveryErr error
@@ -343,7 +351,7 @@ func (p *WorktreePhase) walkChangedStack(
 	discoveryGroup.Go(func() error {
 		toDiscovery := NewDiscovery(toStack.Path()).
 			WithDiscoveryContext(toDiscoveryContext).
-			WithFilters(filter.Filters{}).
+			WithFilters(parentFilters).
 			WithNumWorkers(p.numWorkers)
 
 		var toDiscoveryErr error

internal/discovery/phase_worktree_integration_test.go

@@ -2365,3 +2365,93 @@ unit "myapp" {
 		"Expected at least one unit to be discovered when a read file changes, "+
 			"but got no units. All components: %v", componentPaths)
 }
+
+// TestWorktreePhase_Integration_NegatedFiltersAppliedInWorktreeSubDiscoveries tests that
+// negated path filters (e.g., from .terragrunt-filters) are applied within worktree
+// sub-discoveries, not just during the final filter evaluation.
+// This is a regression test for #5821: source catalog units in worktrees were being
+// discovered and parsed despite being excluded by a negated path filter, because the
+// worktree sub-discoveries did not receive the exclusion filters.
+func TestWorktreePhase_Integration_NegatedFiltersAppliedInWorktreeSubDiscoveries(t *testing.T) {
+	t.Parallel()
+
+	tmpDir, runner := setupGitRepo(t)
+
+	// Create two units: one that should be discovered and one that should be excluded.
+	createUnit(t, tmpDir, "app", `# App unit`)
+	// This catalog unit references values.* — it's a template that only works
+	// when generated through a stack. Without the fix, the worktree sub-discovery
+	// tries to parse it and fails with "Unknown variable: values".
+	createUnit(t, tmpDir, "catalog/units/svc", `
+locals {
+  environment = values.environment
+}
+`)
+
+	commitChanges(t, runner, "Initial commit")
+
+	// Modify both units
+	err := os.WriteFile(filepath.Join(tmpDir, "app", "terragrunt.hcl"), []byte(`# Modified app`), 0o644)
+	require.NoError(t, err)
+
+	err = os.WriteFile(filepath.Join(tmpDir, "catalog", "units", "svc", "terragrunt.hcl"), []byte(`
+locals {
+  environment = values.environment
+  region      = "us-east-1"
+}
+`), 0o644)
+	require.NoError(t, err)
+
+	commitChanges(t, runner, "Modify both units")
+
+	l := logger.CreateLogger()
+
+	// Parse filters: git expression + negated path that excludes catalog
+	filterQueries := []string{"[HEAD~1...HEAD]", "!./catalog/**"}
+	filters, parseErr := filter.ParseFilterQueries(l, filterQueries)
+	require.NoError(t, parseErr)
+
+	w, err := worktrees.NewWorktrees(t.Context(), l, worktrees.WorktreeOpts{
+		WorkingDir:     tmpDir,
+		GitExpressions: filters.UniqueGitFilters(),
+	})
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		cleanupErr := w.Cleanup(context.WithoutCancel(t.Context()), l)
+		require.NoError(t, cleanupErr)
+	})
+
+	opts := options.NewTerragruntOptions()
+	opts.WorkingDir = tmpDir
+	opts.RootWorkingDir = tmpDir
+
+	d := discovery.NewDiscovery(tmpDir).
+		WithDiscoveryContext(&component.DiscoveryContext{
+			WorkingDir: tmpDir,
+			Cmd:        "plan",
+		}).
+		WithWorktrees(w).
+		WithRelationships().
+		WithFilters(filters)
+
+	components, err := d.Discover(t.Context(), l, opts)
+	require.NoError(t, err)
+
+	unitPaths := components.Filter(component.UnitKind).Paths()
+
+	worktreePair := w.WorktreePairs["[HEAD~1...HEAD]"]
+	require.NotEmpty(t, worktreePair)
+
+	toWorktree := worktreePair.ToWorktree.Path
+
+	// The app unit should be discovered (it's in the git diff and not excluded)
+	assert.Contains(t, unitPaths, filepath.Join(toWorktree, "app"),
+		"app unit should be discovered")
+
+	// The catalog unit should NOT be discovered (excluded by !./catalog/**)
+	for _, p := range unitPaths {
+		assert.NotContains(t, p, "catalog",
+			"catalog units should be excluded by the negated filter, but found: %s", p)
+	}
+}

internal/filter/filters.go

@@ -93,6 +93,21 @@ func (f Filters) RequiresParse() (Expression, bool) {
 	return nil, false
 }
 
+// ExcludingGitFilters returns all filters that do not contain a git expression.
+// Git expressions are excluded because they are handled by the worktree phase
+// itself and would cause infinite recursion if propagated to sub-discoveries.
+func (f Filters) ExcludingGitFilters() Filters {
+	result := make(Filters, 0, len(f))
+
+	for _, filter := range f {
+		if !containsGitExpression(filter.expr) {
+			result = append(result, filter)
+		}
+	}
+
+	return result
+}
+
 // DependencyGraphExpressions returns all target expressions from graph expressions that require dependency traversal.
 func (f Filters) DependencyGraphExpressions() []Expression {
 	targets := make([]Expression, 0, len(f))
@@ -139,73 +154,15 @@ func (f Filters) UniqueGitFilters() GitExpressions {
 
 // RestrictToStacks returns a new Filters object with only the filters that are restricted to stacks.
 func (f Filters) RestrictToStacks() Filters {
-	return slices.Collect(func(yield func(*Filter) bool) {
-		for _, filter := range f {
-			if filter.expr.IsRestrictedToStacks() && !yield(filter) {
-				return
-			}
-		}
-	})
-}
-
-// collectGraphExpressionTargetsWithDependencies collects target expressions from GraphExpression nodes that have IncludeDependencies set.
-func collectGraphExpressionTargetsWithDependencies(expr Expression) []Expression {
-	var targets []Expression
-
-	WalkExpressions(expr, func(e Expression) bool {
-		if graphExpr, ok := e.(*GraphExpression); ok && graphExpr.IncludeDependencies {
-			targets = append(targets, graphExpr.Target)
-		}
-
-		return true
-	})
-
-	return targets
-}
-
-// collectGraphExpressionTargetsWithDependents collects target expressions from GraphExpression nodes that have IncludeDependents set.
-func collectGraphExpressionTargetsWithDependents(expr Expression) []Expression {
-	var targets []Expression
-
-	WalkExpressions(expr, func(e Expression) bool {
-		if graphExpr, ok := e.(*GraphExpression); ok && graphExpr.IncludeDependents {
-			targets = append(targets, graphExpr.Target)
-		}
-
-		return true
-	})
-
-	return targets
-}
-
-// collectWorktreeExpressions collects worktree expressions from GitExpression nodes.
-func collectWorktreeExpressions(expr Expression) []*GitExpression {
-	var targets []*GitExpression
-
-	WalkExpressions(expr, func(e Expression) bool {
-		if gitExpr, ok := e.(*GitExpression); ok {
-			targets = append(targets, gitExpr)
-		}
+	result := make(Filters, 0, len(f))
 
-		return true
-	})
-
-	return targets
-}
-
-// collectGitReferences collects Git references from GitExpression nodes.
-func collectGitReferences(expr Expression) []string {
-	var refs []string
-
-	WalkExpressions(expr, func(e Expression) bool {
-		if gitExpr, ok := e.(*GitExpression); ok {
-			refs = append(refs, gitExpr.FromRef, gitExpr.ToRef)
+	for _, filter := range f {
+		if filter.expr.IsRestrictedToStacks() {
+			result = append(result, filter)
 		}
+	}
 
-		return true
-	})
-
-	return refs
+	return result
 }
 
 // Evaluate applies all filters with union (OR) semantics in two phases:
@@ -307,6 +264,37 @@ func (f Filters) EvaluateOnFiles(l log.Logger, files []string, workingDir string
 	return f.Evaluate(l, comps)
 }
 
+// String returns a JSON array representation of all filter strings.
+func (f Filters) String() string {
+	filterStrings := make([]string, len(f))
+	for i, filter := range f {
+		filterStrings[i] = filter.String()
+	}
+
+	jsonBytes, err := json.Marshal(filterStrings)
+	if err != nil {
+		return "[]"
+	}
+
+	return string(jsonBytes)
+}
+
+// containsGitExpression returns true if the expression tree contains a GitExpression.
+func containsGitExpression(expr Expression) bool {
+	found := false
+
+	WalkExpressions(expr, func(e Expression) bool {
+		if _, ok := e.(*GitExpression); ok {
+			found = true
+			return false
+		}
+
+		return true
+	})
+
+	return found
+}
+
 func initialComponents(l log.Logger, positiveFilters []*Filter, components component.Components) (component.Components, error) {
 	if len(positiveFilters) == 0 {
 		return components, nil
@@ -333,17 +321,58 @@ func initialComponents(l log.Logger, positiveFilters []*Filter, components compo
 	return remaining, nil
 }
 
-// String returns a JSON array representation of all filter strings.
-func (f Filters) String() string {
-	filterStrings := make([]string, len(f))
-	for i, filter := range f {
-		filterStrings[i] = filter.String()
-	}
+func collectGraphExpressionTargetsWithDependencies(expr Expression) []Expression {
+	var targets []Expression
 
-	jsonBytes, err := json.Marshal(filterStrings)
-	if err != nil {
-		return "[]"
-	}
+	WalkExpressions(expr, func(e Expression) bool {
+		if graphExpr, ok := e.(*GraphExpression); ok && graphExpr.IncludeDependencies {
+			targets = append(targets, graphExpr.Target)
+		}
 
-	return string(jsonBytes)
+		return true
+	})
+
+	return targets
+}
+
+func collectGraphExpressionTargetsWithDependents(expr Expression) []Expression {
+	var targets []Expression
+
+	WalkExpressions(expr, func(e Expression) bool {
+		if graphExpr, ok := e.(*GraphExpression); ok && graphExpr.IncludeDependents {
+			targets = append(targets, graphExpr.Target)
+		}
+
+		return true
+	})
+
+	return targets
+}
+
+func collectGitReferences(expr Expression) []string {
+	var refs []string
+
+	WalkExpressions(expr, func(e Expression) bool {
+		if gitExpr, ok := e.(*GitExpression); ok {
+			refs = append(refs, gitExpr.FromRef, gitExpr.ToRef)
+		}
+
+		return true
+	})
+
+	return refs
+}
+
+func collectWorktreeExpressions(expr Expression) []*GitExpression {
+	var targets []*GitExpression
+
+	WalkExpressions(expr, func(e Expression) bool {
+		if gitExpr, ok := e.(*GitExpression); ok {
+			targets = append(targets, gitExpr)
+		}
+
+		return true
+	})
+
+	return targets
 }

internal/stacks/generate/generate.go

@@ -380,7 +380,7 @@ func worktreeStacksToGenerate(
 
 		g.Go(func() error {
 			// Discover all stacks in both worktrees for generation.
-			allFromStacks, err := discoverStacks(ctx, l, opts, pair.FromWorktree, nil)
+			allFromStacks, err := discoverStacks(ctx, l, opts, pair.FromWorktree, false)
 			if err != nil {
 				mu.Lock()
 
@@ -390,12 +390,10 @@ func worktreeStacksToGenerate(
 				return nil
 			}
 
-			// Appending the reading filter to the "to" discovery forces all stacks through
+			// The "to" discovery uses readFiles to force all stacks through
 			// the parse phase (populating Reading()), while still returning every stack
 			// (because they all match type=stack).
-			readingFilters := filter.Filters{filter.NewFilter(parseExpr, parseExpr.String())}
-
-			allToStacks, err := discoverStacks(ctx, l, opts, pair.ToWorktree, readingFilters)
+			allToStacks, err := discoverStacks(ctx, l, opts, pair.ToWorktree, true)
 			if err != nil {
 				mu.Lock()
 
@@ -474,22 +472,28 @@ func worktreeStacksToGenerate(
 	return stacksToGenerate.ToComponents(), nil
 }
 
-// discoverStacks discovers stacks in a worktree using the given additional filters.
+// discoverStacks discovers stacks in a worktree.
 // User-provided filters from opts.Filters are included (restricted to stacks) so that
 // explicit exclusions like --filter '!./land-mine | type=stack' are respected.
+// When readFiles is true, all discovered stacks are parsed to populate their Reading
+// attribute (used by reading-affected detection).
 func discoverStacks(
 	ctx context.Context,
 	l log.Logger,
 	opts *options.TerragruntOptions,
 	wt worktrees.Worktree,
-	additionalFilters filter.Filters,
+	readFiles bool,
 ) (component.Components, error) {
-	allFilters := slices.Concat(stackTypeFilter(), opts.Filters.RestrictToStacks(), additionalFilters)
+	allFilters := slices.Concat(stackTypeFilter(), opts.Filters.RestrictToStacks())
 
 	d := discovery.NewDiscovery(wt.Path).
 		WithSuppressParseErrors().
 		WithFilters(allFilters)
 
+	if readFiles {
+		d = d.WithReadFiles()
+	}
+
 	components, err := d.Discover(ctx, l, opts)
 	if err != nil {
 		return nil, errors.Errorf("failed to discover stacks in worktree %s: %w", wt.Ref, err)