bug: handling of auto include parsing errors

Author: denis256

internal/discovery/helpers.go

@@ -290,7 +290,11 @@ func stackDependencyPaths(fs vfs.FS, depPaths []string, c component.Component) (
 	expanded := make([]string, 0, len(depPaths))
 
 	for _, depPath := range depPaths {
-		unitPaths := inthclparse.UnitPathsFromStackDir(fs, depPath)
+		unitPaths, upErr := inthclparse.UnitPathsFromStackDir(fs, depPath)
+		if upErr != nil {
+			return nil, upErr
+		}
+
 		if len(unitPaths) > 0 {
 			expanded = append(expanded, unitPaths...)
 

internal/hclparse/autoinclude.go

@@ -202,21 +202,31 @@ func AutoIncludeDependencyPaths(fs vfs.FS, unitDir string) ([]string, error) {
 		return nil, UnexpectedBodyTypeError{FilePath: autoIncludePath}
 	}
 
-	var paths []string
+	paths := make([]string, 0, len(body.Blocks))
 
 	for _, block := range body.Blocks {
 		if block.Type != blockDependency || len(block.Labels) == 0 {
 			continue
 		}
 
+		name := block.Labels[0]
+
 		configPathAttr, exists := block.Body.Attributes[attrConfigPath]
 		if !exists {
-			continue
+			return nil, MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "missing config_path attribute"}
 		}
 
 		val, valDiags := configPathAttr.Expr.Value(nil)
-		if valDiags.HasErrors() || !val.IsKnown() || val.IsNull() || val.Type() != cty.String {
-			continue
+		if valDiags.HasErrors() {
+			return nil, MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path: " + valDiags.Error()}
+		}
+
+		if !val.IsKnown() || val.IsNull() {
+			return nil, MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path is null or unknown"}
+		}
+
+		if val.Type() != cty.String {
+			return nil, MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path must be a string literal"}
 		}
 
 		depPath := val.AsString()

internal/hclparse/errors.go

@@ -133,3 +133,14 @@ type LocalsMaxIterError struct {
 func (e LocalsMaxIterError) Error() string {
 	return fmt.Sprintf("locals evaluation exceeded %d iterations with %d unresolved locals", e.MaxIterations, e.Remaining)
 }
+
+// MalformedDependencyError indicates a dependency block in an autoinclude file is malformed.
+type MalformedDependencyError struct {
+	FilePath string
+	Name     string
+	Reason   string
+}
+
+func (e MalformedDependencyError) Error() string {
+	return fmt.Sprintf("malformed dependency %q in %s: %s", e.Name, e.FilePath, e.Reason)
+}

internal/hclparse/fuzz_test.go

@@ -267,8 +267,7 @@ unit "app" { source = "."; path = "app"
 			StackDir: "/fuzz/live",
 		})
 
-		// Also exercise DiscoverStackChildUnits directly on the middle stack.
-		_ = hclparse.DiscoverStackChildUnits(fs, "/fuzz/stacks/mid", "/fuzz/gen")
+		_, _ = hclparse.DiscoverStackChildUnits(fs, "/fuzz/stacks/mid", "/fuzz/gen")
 	})
 }
 

internal/hclparse/parse.go

@@ -85,7 +85,11 @@ func ParseStackFile(fs vfs.FS, input *ParseStackFileInput) (*ParseResult, error)
 	stackTargetDir := filepath.Join(input.StackDir, StackDir)
 
 	unitRefs := buildRefsWithAbsPath(stackTargetDir, stackFile.Units)
-	stackRefs := buildStackRefsWithAbsPath(fs, input.StackDir, stackTargetDir, stackFile.Stacks, 0)
+
+	stackRefs, err := buildStackRefsWithAbsPath(fs, input.StackDir, stackTargetDir, stackFile.Stacks, 0)
+	if err != nil {
+		return nil, err
+	}
 
 	// Pass 2: resolve autoinclude blocks using the eval context.
 	evalCtx := BuildAutoIncludeEvalContext(unitRefs, stackRefs)
@@ -388,32 +392,29 @@ func buildRefsWithAbsPath(stackTargetDir string, units []*UnitBlockHCL) []Compon
 	return refs
 }
 
-// buildStackRefsWithAbsPath creates ComponentRef values for stack blocks.
-// It also attempts to parse each stack's source to discover child units,
-// enabling stack.stack_name.unit_name.path references.
-// depth is threaded to prevent unbounded recursion in circular stacks.
-func buildStackRefsWithAbsPath(fs vfs.FS, stackDir string, stackTargetDir string, stacks []*StackBlockHCL, depth int) []ComponentRef {
+// buildStackRefsWithAbsPath builds ComponentRef values for stack blocks and discovers their child units.
+func buildStackRefsWithAbsPath(fs vfs.FS, stackDir string, stackTargetDir string, stacks []*StackBlockHCL, depth int) ([]ComponentRef, error) {
 	refs := make([]ComponentRef, 0, len(stacks))
 
 	for _, s := range stacks {
 		stackGenPath := filepath.Join(stackTargetDir, s.Path)
 
-		ref := ComponentRef{
-			Name: s.Name,
-			Path: stackGenPath,
-		}
-
-		// Resolve the source to find nested units within this stack.
-		// The source may be relative to the stack file's directory.
 		sourceDir := s.Source
 		if !filepath.IsAbs(sourceDir) {
 			sourceDir = filepath.Join(stackDir, sourceDir)
 		}
 
-		ref.ChildRefs = discoverStackChildUnitsWithDepth(fs, sourceDir, stackGenPath, depth+1)
+		childRefs, err := discoverStackChildUnitsWithDepth(fs, sourceDir, stackGenPath, depth+1)
+		if err != nil {
+			return nil, err
+		}
 
-		refs = append(refs, ref)
+		refs = append(refs, ComponentRef{
+			Name:      s.Name,
+			Path:      stackGenPath,
+			ChildRefs: childRefs,
+		})
 	}
 
-	return refs
+	return refs, nil
 }

internal/hclparse/stack.go

@@ -204,15 +204,17 @@ func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error) {
 	})
 }
 
-// UnitPathsFromStackDir parses the stack file in stackDir and returns
-// absolute paths to each unit's generated directory under .terragrunt-stack/.
-// Returns nil if the file does not exist or cannot be parsed.
-func UnitPathsFromStackDir(fs vfs.FS, stackDir string) []string {
+// UnitPathsFromStackDir parses the stack file in stackDir and returns paths to each unit's generated directory.
+func UnitPathsFromStackDir(fs vfs.FS, stackDir string) ([]string, error) {
 	stackDir = util.ResolvePath(stackDir)
 
 	result, err := ParseStackFileFromPath(fs, stackDir)
-	if err != nil || result == nil {
-		return nil
+	if err != nil {
+		return nil, err
+	}
+
+	if result == nil {
+		return nil, nil
 	}
 
 	paths := make([]string, 0, len(result.Units))
@@ -226,32 +228,30 @@ func UnitPathsFromStackDir(fs vfs.FS, stackDir string) []string {
 		paths = append(paths, unitPath)
 	}
 
-	return paths
+	return paths, nil
 }
 
 // maxDiscoverDepth is the maximum recursion depth for DiscoverStackChildUnits
 // to prevent infinite loops from circular stack references.
 const maxDiscoverDepth = 1000
 
-// DiscoverStackChildUnits parses a stack's source directory to find the
-// terragrunt.stack.hcl within it and extracts unit paths. This enables
-// stack.stack_name.unit_name.path references in autoinclude blocks.
-//
-// stackSourceDir is the directory where the stack's source files live
-// (or will be generated). stackGenDir is the absolute path where this
-// stack's units will be generated (.terragrunt-stack/stack_path/).
-func DiscoverStackChildUnits(fs vfs.FS, stackSourceDir, stackGenDir string) []ComponentRef {
+// DiscoverStackChildUnits parses a stack's source dir for stack.<name>.<unit>.path resolution.
+func DiscoverStackChildUnits(fs vfs.FS, stackSourceDir, stackGenDir string) ([]ComponentRef, error) {
 	return discoverStackChildUnitsWithDepth(fs, stackSourceDir, stackGenDir, 0)
 }
 
-func discoverStackChildUnitsWithDepth(fs vfs.FS, stackSourceDir, stackGenDir string, depth int) []ComponentRef {
+func discoverStackChildUnitsWithDepth(fs vfs.FS, stackSourceDir, stackGenDir string, depth int) ([]ComponentRef, error) {
 	if depth > maxDiscoverDepth {
-		return nil
+		return nil, nil
 	}
 
 	result, err := ParseStackFileFromPath(fs, stackSourceDir)
-	if err != nil || result == nil {
-		return nil
+	if err != nil {
+		return nil, err
+	}
+
+	if result == nil {
+		return nil, nil
 	}
 
 	childTargetDir := filepath.Join(stackGenDir, StackDir)
@@ -270,7 +270,6 @@ func discoverStackChildUnitsWithDepth(fs vfs.FS, stackSourceDir, stackGenDir str
 		})
 	}
 
-	// Also discover nested stacks so stack.<name>.<nested_stack>.path works.
 	for _, s := range result.Stacks {
 		nestedGenPath := filepath.Join(childTargetDir, s.Path)
 
@@ -279,14 +278,17 @@ func discoverStackChildUnitsWithDepth(fs vfs.FS, stackSourceDir, stackGenDir str
 			nestedSourceDir = filepath.Join(stackSourceDir, nestedSourceDir)
 		}
 
-		ref := ComponentRef{
-			Name:      s.Name,
-			Path:      nestedGenPath,
-			ChildRefs: discoverStackChildUnitsWithDepth(fs, nestedSourceDir, nestedGenPath, depth+1),
+		childRefs, childErr := discoverStackChildUnitsWithDepth(fs, nestedSourceDir, nestedGenPath, depth+1)
+		if childErr != nil {
+			return nil, childErr
 		}
 
-		refs = append(refs, ref)
+		refs = append(refs, ComponentRef{
+			Name:      s.Name,
+			Path:      nestedGenPath,
+			ChildRefs: childRefs,
+		})
 	}
 
-	return refs
+	return refs, nil
 }

internal/hclparse/stack_test.go

@@ -183,8 +183,8 @@ unit "db" {
 }
 `), 0644))
 
-	refs := hclparse.DiscoverStackChildUnits(fs, "/test/stack-src", "/gen/networking")
-
+	refs, err := hclparse.DiscoverStackChildUnits(fs, "/test/stack-src", "/gen/networking")
+	require.NoError(t, err)
 	require.Len(t, refs, 2)
 	assert.Equal(t, "vpc", refs[0].Name)
 	assert.Equal(t, filepath.Join("/gen/networking", ".terragrunt-stack", "vpc"), refs[0].Path)
@@ -210,13 +210,11 @@ unit "db" {
 }
 `), 0644))
 
-	refs := hclparse.DiscoverStackChildUnits(fs, "/test/stack-src", "/gen/networking")
-
+	refs, err := hclparse.DiscoverStackChildUnits(fs, "/test/stack-src", "/gen/networking")
+	require.NoError(t, err)
 	require.Len(t, refs, 2)
-	// vpc has no_dot_terragrunt_stack=true, goes directly under stackGenDir
 	assert.Equal(t, "vpc", refs[0].Name)
 	assert.Equal(t, filepath.Join("/gen/networking", "vpc"), refs[0].Path)
-	// db is normal, goes under .terragrunt-stack/
 	assert.Equal(t, "db", refs[1].Name)
 	assert.Equal(t, filepath.Join("/gen/networking", ".terragrunt-stack", "db"), refs[1].Path)
 }
@@ -226,7 +224,8 @@ func TestDiscoverStackChildUnits_NoStackFile(t *testing.T) {
 
 	fs := vfs.NewMemMapFS()
 
-	refs := hclparse.DiscoverStackChildUnits(fs, "/nonexistent", "/gen")
+	refs, err := hclparse.DiscoverStackChildUnits(fs, "/nonexistent", "/gen")
+	require.NoError(t, err)
 	assert.Nil(t, refs)
 }
 
@@ -273,7 +272,8 @@ unit "db" {
 }
 `), 0644))
 
-	paths := hclparse.UnitPathsFromStackDir(fs, "/test")
+	paths, err := hclparse.UnitPathsFromStackDir(fs, "/test")
+	require.NoError(t, err)
 	require.Len(t, paths, 2)
 	assert.Contains(t, paths[0], ".terragrunt-stack")
 	assert.Contains(t, paths[1], ".terragrunt-stack")
@@ -285,15 +285,31 @@ func TestUnitPathsFromStackDir_NotAStack(t *testing.T) {
 	fs := vfs.NewMemMapFS()
 	require.NoError(t, fs.MkdirAll("/test", 0755))
 
-	assert.Nil(t, hclparse.UnitPathsFromStackDir(fs, "/test"))
+	paths, err := hclparse.UnitPathsFromStackDir(fs, "/test")
+	require.NoError(t, err)
+	assert.Nil(t, paths)
 }
 
 func TestUnitPathsFromStackDir_Nonexistent(t *testing.T) {
 	t.Parallel()
 
 	fs := vfs.NewMemMapFS()
 
-	assert.Nil(t, hclparse.UnitPathsFromStackDir(fs, "/nonexistent"))
+	paths, err := hclparse.UnitPathsFromStackDir(fs, "/nonexistent")
+	require.NoError(t, err)
+	assert.Nil(t, paths)
+}
+
+func TestUnitPathsFromStackDir_MalformedReturnsError(t *testing.T) {
+	t.Parallel()
+
+	fs := vfs.NewMemMapFS()
+	require.NoError(t, fs.MkdirAll("/test", 0755))
+	require.NoError(t, vfs.WriteFile(fs, "/test/terragrunt.stack.hcl", []byte(`unit "x" { source = "." `), 0644))
+
+	paths, err := hclparse.UnitPathsFromStackDir(fs, "/test")
+	require.Error(t, err)
+	assert.Nil(t, paths)
 }
 
 func TestParseStackFileFromPath(t *testing.T) {
@@ -370,8 +386,8 @@ unit "vpc" {
 	symlinkDir := filepath.Join(tmpDir, "symlinked-stack")
 	require.NoError(t, os.Symlink(realDir, symlinkDir))
 
-	// UnitPathsFromStackDir via symlink should return paths based on resolved real dir
-	paths := hclparse.UnitPathsFromStackDir(vfs.NewOSFS(), symlinkDir)
+	paths, err := hclparse.UnitPathsFromStackDir(vfs.NewOSFS(), symlinkDir)
+	require.NoError(t, err)
 	require.Len(t, paths, 1)
 	// Path should be based on the REAL directory, not the symlink
 	assert.Contains(t, paths[0], "real-stack")
@@ -397,12 +413,24 @@ unit "db" {
 	symlinkSrcDir := filepath.Join(tmpDir, "symlinked-source")
 	require.NoError(t, os.Symlink(realSrcDir, symlinkSrcDir))
 
-	// DiscoverStackChildUnits via symlink should work
-	refs := hclparse.DiscoverStackChildUnits(vfs.NewOSFS(), symlinkSrcDir, "/gen/stack")
+	refs, err := hclparse.DiscoverStackChildUnits(vfs.NewOSFS(), symlinkSrcDir, "/gen/stack")
+	require.NoError(t, err)
 	require.Len(t, refs, 1)
 	assert.Equal(t, "db", refs[0].Name)
 }
 
+func TestDiscoverStackChildUnits_MalformedReturnsError(t *testing.T) {
+	t.Parallel()
+
+	fs := vfs.NewMemMapFS()
+	require.NoError(t, fs.MkdirAll("/test/stack-src", 0755))
+	require.NoError(t, vfs.WriteFile(fs, "/test/stack-src/terragrunt.stack.hcl", []byte(`unit "x" { source = "."`), 0644))
+
+	refs, err := hclparse.DiscoverStackChildUnits(fs, "/test/stack-src", "/gen")
+	require.Error(t, err)
+	assert.Nil(t, refs)
+}
+
 func TestParseStackFile_WithInclude(t *testing.T) {
 	t.Parallel()
 

test/fixtures/stacks/stack-deps-issue-5980/live/terragrunt.stack.hcl

@@ -0,0 +1,29 @@
+// Regression fixture for issue #5980: stack file uses an HCL function in path that
+// only the production parser has registered (the simplified two-pass autoinclude
+// parser uses nil eval context). With an autoinclude block declared, this must fail
+// loudly during stack generate instead of silently skipping autoinclude generation.
+
+unit "vpc" {
+  source = "../catalog/units/vpc"
+  path   = format("%s", "vpc")
+}
+
+unit "subnet" {
+  source = "../catalog/units/subnet"
+  path   = "subnet"
+
+  autoinclude {
+    dependency "vpc" {
+      config_path = unit.vpc.path
+
+      mock_outputs_allowed_terraform_commands = ["validate", "plan", "apply"]
+      mock_outputs = {
+        id = "mock-id"
+      }
+    }
+
+    inputs = {
+      vpc_id = dependency.vpc.outputs.id
+    }
+  }
+}