Added passing of parser options

Author: denis256

internal/discovery/discovery.go

@@ -29,6 +29,8 @@ const (
 	ConfigTypeUnit ConfigType = "unit"
 	// ConfigTypeStack is the type of Terragrunt configuration for a stack.
 	ConfigTypeStack ConfigType = "stack"
+
+	skipOutputDiagnostics = "output"
 )
 
 // ConfigType is the type of Terragrunt configuration.
@@ -116,6 +118,9 @@ type Discovery struct {
 
 	// excludeByDefault determines whether to exclude configurations by default (triggered by include flags).
 	excludeByDefault bool
+
+	// parserOptions are custom HCL parser options to use when parsing during discovery
+	parserOptions []hclparse.Option
 }
 
 // DiscoveryOption is a function that modifies a Discovery.
@@ -140,6 +145,26 @@ func NewDiscovery(dir string, opts ...DiscoveryOption) *Discovery {
 	return discovery
 }
 
+// parseOptionsProvider is a narrow interface used to extract parser options from
+// option values without introducing a dependency on runner or stack packages.
+type parseOptionsProvider interface {
+	GetParseOptions() ([]hclparse.Option, bool)
+}
+
+// WithOptions applies any provided options that expose parser options.
+// Accepts any option types; only those implementing GetParseOptions are used.
+func (d *Discovery) WithOptions(opts ...any) *Discovery { //nolint: revive
+	for _, opt := range opts {
+		if provider, ok := opt.(parseOptionsProvider); ok {
+			if parseOpts, ok := provider.GetParseOptions(); ok {
+				d = d.WithParserOptions(parseOpts)
+			}
+		}
+	}
+
+	return d
+}
+
 // WithHidden sets the Hidden flag to true.
 func (d *Discovery) WithHidden() *Discovery {
 	d.hidden = true
@@ -243,6 +268,12 @@ func (d *Discovery) WithExcludeByDefault() *Discovery {
 	return d
 }
 
+// WithParserOptions sets custom parser options to be used when parsing configs during discovery.
+func (d *Discovery) WithParserOptions(options []hclparse.Option) *Discovery {
+	d.parserOptions = options
+	return d
+}
+
 // String returns a string representation of a DiscoveredConfig.
 func (c *DiscoveredConfig) String() string {
 	return c.Path
@@ -265,7 +296,7 @@ func (c *DiscoveredConfig) ContainsDependencyInAncestry(path string) bool {
 }
 
 // Parse parses the discovered configurations.
-func (c *DiscoveredConfig) Parse(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, suppressParseErrors bool) error {
+func (c *DiscoveredConfig) Parse(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, suppressParseErrors bool, parserOptions []hclparse.Option) error {
 	parseOpts := opts.Clone()
 	parseOpts.WorkingDir = c.Path
 
@@ -292,15 +323,20 @@ func (c *DiscoveredConfig) Parse(ctx context.Context, l log.Logger, opts *option
 		config.ExcludeBlock,
 	)
 
+	// Apply any custom parser options first
+	if len(parserOptions) > 0 {
+		parsingCtx = parsingCtx.WithParseOption(append(parsingCtx.ParserOptions, parserOptions...))
+	}
+
 	if suppressParseErrors {
 		// If suppressing parse errors, we want to filter diagnostics that contain references to outputs,
 		// while leaving other diagnostics as is.
 		parseOptions := append(parsingCtx.ParserOptions, hclparse.WithDiagnosticsHandler(func(file *hcl.File, hclDiags hcl.Diagnostics) (hcl.Diagnostics, error) {
 			filteredDiags := hcl.Diagnostics{}
 
 			for _, hclDiag := range hclDiags {
-				containsOutputRef := strings.Contains(strings.ToLower(hclDiag.Summary), "output") ||
-					strings.Contains(strings.ToLower(hclDiag.Detail), "output")
+				containsOutputRef := strings.Contains(strings.ToLower(hclDiag.Summary), skipOutputDiagnostics) ||
+					strings.Contains(strings.ToLower(hclDiag.Detail), skipOutputDiagnostics)
 
 				if !containsOutputRef {
 					filteredDiags = append(filteredDiags, hclDiag)
@@ -557,7 +593,7 @@ func (d *Discovery) Discover(ctx context.Context, l log.Logger, opts *options.Te
 				continue
 			}
 
-			err := cfg.Parse(ctx, l, opts, d.suppressParseErrors)
+			err := cfg.Parse(ctx, l, opts, d.suppressParseErrors, d.parserOptions)
 			if err != nil {
 				errs = append(errs, errors.New(err))
 			}
@@ -585,6 +621,10 @@ func (d *Discovery) Discover(ctx context.Context, l log.Logger, opts *options.Te
 				dependencyDiscovery = dependencyDiscovery.WithSuppressParseErrors()
 			}
 
+			if len(d.parserOptions) > 0 {
+				dependencyDiscovery = dependencyDiscovery.WithParserOptions(d.parserOptions)
+			}
+
 			// Pass include patterns and strict mode to dependency discovery
 			if len(d.includeDirs) > 0 {
 				dependencyDiscovery = dependencyDiscovery.WithIncludeDirs(d.includeDirs)
@@ -647,6 +687,7 @@ type DependencyDiscovery struct {
 	discoverExternal    bool
 	suppressParseErrors bool
 	strictInclude       bool
+	parserOptions       []hclparse.Option
 }
 
 // DependencyDiscoveryOption is a function that modifies a DependencyDiscovery.
@@ -691,6 +732,12 @@ func (d *DependencyDiscovery) WithStrictInclude() *DependencyDiscovery {
 	return d
 }
 
+// WithParserOptions sets custom parser options to be used when parsing dependency configs during discovery.
+func (d *DependencyDiscovery) WithParserOptions(options []hclparse.Option) *DependencyDiscovery {
+	d.parserOptions = options
+	return d
+}
+
 // matchesIncludePatterns returns true if the path matches any of the include directory patterns.
 func (d *DependencyDiscovery) matchesIncludePatterns(path string) bool {
 	if len(d.includeDirs) == 0 {
@@ -752,7 +799,7 @@ func (d *DependencyDiscovery) DiscoverDependencies(ctx context.Context, l log.Lo
 
 	// This should only happen if we're discovering an ancestor dependency.
 	if dCfg.Parsed == nil {
-		err := dCfg.Parse(ctx, l, opts, d.suppressParseErrors)
+		err := dCfg.Parse(ctx, l, opts, d.suppressParseErrors, d.parserOptions)
 		if err != nil {
 			return errors.New(err)
 		}

internal/runner/common/options.go

@@ -6,25 +6,68 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/report"
 )
 
-// Option is a function that modifies a Stack.
-type Option func(StackRunner)
+// ParseOptionsSetter is a minimal interface for types that can accept parser options.
+// Both stack runners and discovery implement SetParseOptions with this signature.
+type ParseOptionsSetter interface {
+	SetParseOptions(parserOptions []hclparse.Option)
+}
+
+// Option applies configuration to the StackRunner.
+type Option interface {
+	ApplyStack(stack StackRunner)
+}
+
+type optionImpl struct {
+	applyStack      func(StackRunner)
+	parserOptions   []hclparse.Option
+	hasParseOptions bool
+}
+
+func (o optionImpl) ApplyStack(stack StackRunner) {
+	if o.applyStack != nil {
+		o.applyStack(stack)
+	}
+}
+
+// ParseOptionsProvider allows extracting parser options from an Option without applying it to a stack.
+type ParseOptionsProvider interface {
+	GetParseOptions() ([]hclparse.Option, bool)
+}
+
+// GetParseOptions returns parser options when the option was created by WithParseOptions.
+func (o optionImpl) GetParseOptions() ([]hclparse.Option, bool) {
+	if o.hasParseOptions {
+		return o.parserOptions, true
+	}
+
+	return nil, false
+}
 
 // WithChildTerragruntConfig sets the TerragruntConfig on any Stack implementation.
-func WithChildTerragruntConfig(config *config.TerragruntConfig) Option {
-	return func(stack StackRunner) {
-		stack.SetTerragruntConfig(config)
+func WithChildTerragruntConfig(cfg *config.TerragruntConfig) Option {
+	return optionImpl{
+		applyStack: func(stack StackRunner) {
+			stack.SetTerragruntConfig(cfg)
+		},
 	}
 }
 
-// WithParseOptions sets the parserOptions on any Stack implementation.
+// WithParseOptions sets custom HCL parser options on both discovery and stack.
 func WithParseOptions(parserOptions []hclparse.Option) Option {
-	return func(stack StackRunner) {
-		stack.SetParseOptions(parserOptions)
+	return optionImpl{
+		applyStack: func(stack StackRunner) {
+			stack.SetParseOptions(parserOptions)
+		},
+		parserOptions:   parserOptions,
+		hasParseOptions: true,
 	}
 }
 
-func WithReport(report *report.Report) Option {
-	return func(stack StackRunner) {
-		stack.SetReport(report)
+// WithReport attaches a report collector to the stack only.
+func WithReport(r *report.Report) Option {
+	return optionImpl{
+		applyStack: func(stack StackRunner) {
+			stack.SetReport(r)
+		},
 	}
 }

internal/runner/configstack/runner.go

@@ -50,7 +50,7 @@ func NewRunner(l log.Logger, terragruntOptions *options.TerragruntOptions, opts
 // WithOptions updates the stack with the provided options.
 func (runner *Runner) WithOptions(opts ...common.Option) *Runner {
 	for _, opt := range opts {
-		opt(runner)
+		opt.ApplyStack(runner)
 	}
 
 	return runner

internal/runner/runnerpool/builder.go

@@ -17,6 +17,7 @@ func Build(ctx context.Context, l log.Logger, terragruntOptions *options.Terragr
 	// discovery configurations
 	d := discovery.
 		NewDiscovery(terragruntOptions.WorkingDir).
+		WithOptions(opts).
 		WithDiscoverExternalDependencies().
 		WithParseInclude().
 		WithParseExclude().

internal/runner/runnerpool/runner.go

@@ -290,7 +290,7 @@ func (r *Runner) summarizePlanAllErrors(l log.Logger, errorStreams []bytes.Buffe
 // WithOptions updates the stack with the provided options.
 func (r *Runner) WithOptions(opts ...common.Option) *Runner {
 	for _, opt := range opts {
-		opt(r)
+		opt.ApplyStack(r)
 	}
 
 	return r

test/integration_test.go

@@ -727,9 +727,13 @@ func TestHclvalidateReturnsNonZeroExitCodeOnError(t *testing.T) {
 	_, _, err := helpers.RunTerragruntCommandWithOutput(t, "terragrunt hcl validate --working-dir "+rootPath)
 	require.Error(t, err, "terragrunt hcl validate should return a non-zero exit code on HCL errors")
 
-	// As an additional check, we can verify that the error message indicates HCL validation errors.
-	// This makes the test more robust.
-	assert.Contains(t, err.Error(), "HCL validation error(s) found")
+	// As an additional check, verify that the error message indicates HCL validation errors.
+	// Accept either wording depending on the underlying evaluator.
+	errMsg := err.Error()
+	assert.True(t,
+		strings.Contains(errMsg, "HCL validation error(s) found") || strings.Contains(errMsg, "invalid expression"),
+		"error should mention HCL validation issues: got %q", errMsg,
+	)
 }
 
 func TestHclvalidateInvalidConfigPath(t *testing.T) {