chore: parser cleanup

Author: denis256

internal/discovery/helpers.go

@@ -291,13 +291,13 @@ func stackDependencyPaths(fs vfs.FS, depPaths []string, c component.Component) (
 	expanded := make([]string, 0, len(depPaths))
 
 	for _, depPath := range depPaths {
+		// Stat upfront so a non-directory dep path (e.g. another-name.hcl) is preserved instead of being passed to the parser, which would reject it as ENOTDIR. The duplication of work is intentional.
 		info, statErr := fs.Stat(depPath)
 		// Real I/O errors (permission denied, etc.) must surface so a malformed DAG isn't silently produced; only ENOENT is treated as "keep the raw path".
 		if statErr != nil && !errors.Is(statErr, iofs.ErrNotExist) {
 			return nil, NewStackDependencyExpansionError(depPath, statErr)
 		}
 
-		// Dependency paths can also point at non-default-named config files (e.g. another-name.hcl), which the stack-file parser would otherwise reject as "not a directory".
 		if statErr != nil || !info.IsDir() {
 			expanded = append(expanded, depPath)
 			continue

internal/hclparse/parse_test.go

@@ -878,6 +878,46 @@ unit "vpc" {
 	assert.Contains(t, err.Error(), "must not define nested includes")
 }
 
+// Locks the per-file SourceBytes invariant: when a unit's autoinclude block lives in an included stack file, GenerateAutoIncludeFile must use the included file's bytes (not the root's) to slice expression text.
+func TestParseStackFile_AutoIncludeInsideIncludedFile(t *testing.T) {
+	t.Parallel()
+
+	fs := vfs.NewMemMapFS()
+
+	rootSrc := `
+include "shared" {
+  path = "shared.hcl"
+}
+`
+	includedSrc := `
+unit "vpc" {
+  source = "../catalog/units/vpc"
+  path   = "vpc"
+
+  autoinclude {
+    dependency "db" {
+      config_path = "../db"
+    }
+  }
+}
+`
+
+	require.NoError(t, fs.MkdirAll(testStackDir, 0755))
+	require.NoError(t, vfs.WriteFile(fs, filepath.Join(testStackDir, "shared.hcl"), []byte(includedSrc), 0644))
+
+	result, err := hclparse.ParseStackFile(fs, &hclparse.ParseStackFileInput{Src: []byte(rootSrc), Filename: filepath.Join(testStackDir, "terragrunt.stack.hcl"), StackDir: testStackDir})
+	require.NoError(t, err)
+	require.Len(t, result.AutoIncludes, 1)
+
+	resolved, ok := result.AutoIncludes[hclparse.AutoIncludeKey("unit", "vpc")]
+	require.True(t, ok, "expected resolved autoinclude for unit 'vpc'")
+	require.NotNil(t, resolved)
+
+	// SourceBytes must point at the included file's bytes, not the root's, so the generator can slice expression byte ranges correctly.
+	assert.Equal(t, []byte(includedSrc), resolved.SourceBytes, "SourceBytes must equal the included file's bytes")
+	assert.NotEqual(t, []byte(rootSrc), resolved.SourceBytes, "SourceBytes must not be the root file's bytes")
+}
+
 // Benchmarks
 
 func BenchmarkParseStackFile_Simple(b *testing.B) {

internal/hclparse/stack_test.go

@@ -356,7 +356,7 @@ func TestParseStackFileFromPath_StackDirIsFileReturnsError(t *testing.T) {
 
 	var readErr hclparse.FileReadError
 	require.ErrorAs(t, err, &readErr)
-	// ParseStackFileFromPath calls util.ResolvePath, which on macOS resolves /tmp -> /private/tmp; resolve our side too before comparing.
+	// On macOS, t.TempDir() returns paths under /var/folders/... where /var is a symlink to /private/var; util.ResolvePath follows it, so resolve our side too before comparing.
 	resolvedFilePath, evalErr := filepath.EvalSymlinks(filePath)
 	require.NoError(t, evalErr)
 	assert.Equal(t, filepath.Join(resolvedFilePath, "terragrunt.stack.hcl"), readErr.FilePath)