chore: simplified auto include errors

Author: denis256

internal/discovery/helpers.go

@@ -290,6 +290,12 @@ func stackDependencyPaths(fs vfs.FS, depPaths []string, c component.Component) (
 	expanded := make([]string, 0, len(depPaths))
 
 	for _, depPath := range depPaths {
+		// Only expand directories: 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 info, statErr := os.Stat(depPath); statErr != nil || !info.IsDir() {
+			expanded = append(expanded, depPath)
+			continue
+		}
+
 		unitPaths, err := inthclparse.UnitPathsFromStackDir(fs, depPath)
 		if err != nil {
 			return nil, NewStackDependencyExpansionError(depPath, err)

internal/discovery/stack_dependency_expansion_error_test.go

@@ -0,0 +1,38 @@
+package discovery_test
+
+import (
+	"testing"
+
+	"github.com/gruntwork-io/terragrunt/internal/discovery"
+	"github.com/gruntwork-io/terragrunt/internal/hclparse"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Direct typed-error contract test: StackDependencyExpansionError must carry the depPath and unwrap cleanly to the original parser error.
+func TestStackDependencyExpansionError_Unwrap(t *testing.T) {
+	t.Parallel()
+
+	innerErr := hclparse.MalformedDependencyError{
+		FilePath: "/some/path/terragrunt.autoinclude.hcl",
+		Name:     "vpc",
+		Reason:   "missing config_path attribute",
+	}
+
+	wrapped := discovery.NewStackDependencyExpansionError("/path/to/dep", innerErr)
+	require.Error(t, wrapped)
+	assert.Contains(t, wrapped.Error(), "/path/to/dep")
+	assert.Contains(t, wrapped.Error(), "missing config_path")
+
+	// errors.As must reach both the wrapper and the underlying typed error.
+	var expansion discovery.StackDependencyExpansionError
+	require.ErrorAs(t, wrapped, &expansion)
+	assert.Equal(t, "/path/to/dep", expansion.DepPath)
+
+	var malformed hclparse.MalformedDependencyError
+	require.ErrorAs(t, wrapped, &malformed)
+	assert.Equal(t, "vpc", malformed.Name)
+
+	// errors.Is must reach the leaf via Unwrap chain.
+	require.ErrorIs(t, wrapped, innerErr)
+}

internal/hclparse/autoinclude.go

@@ -234,8 +234,11 @@ func AutoIncludeDependencyPaths(fs vfs.FS, unitDir string) ([]string, error) {
 		paths = append(paths, depPath)
 	}
 
-	// Return whatever paths we discovered alongside any errors so callers can decide whether partial DAG enrichment is useful.
-	return paths, errors.Join(errs...)
+	if len(errs) > 0 {
+		return nil, errors.Join(errs...)
+	}
+
+	return paths, nil
 }
 
 // readAutoIncludeBody reads and parses an autoinclude file, returning (nil, nil) when the file does not exist.
@@ -262,10 +265,10 @@ func readAutoIncludeBody(fs vfs.FS, autoIncludePath string) (*hclsyntax.Body, er
 	return body, nil
 }
 
-// blockLabelsString joins a block's labels for error messages; returns "<unlabeled>" when there are none.
+// blockLabelsString joins a block's labels for error messages; returns "(unlabeled)" when there are none.
 func blockLabelsString(block *hclsyntax.Block) string {
 	if len(block.Labels) == 0 {
-		return "<unlabeled>"
+		return "(unlabeled)"
 	}
 
 	return strings.Join(block.Labels, " ")
@@ -282,11 +285,19 @@ func extractDepPath(block *hclsyntax.Block, autoIncludePath, unitDir string) (st
 
 	val, valDiags := configPathAttr.Expr.Value(nil)
 	if valDiags.HasErrors() {
-		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path: " + valDiags.Error(), Wrapped: valDiags}
+		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path: " + valDiags.Error(), Err: valDiags}
+	}
+
+	if !val.IsKnown() {
+		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path is unknown"}
 	}
 
-	if !val.IsKnown() || val.IsNull() || val.Type() != cty.String {
-		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path must be a known string literal"}
+	if val.IsNull() {
+		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path is null"}
+	}
+
+	if val.Type() != cty.String {
+		return "", MalformedDependencyError{FilePath: autoIncludePath, Name: name, Reason: "config_path must be a string, got " + val.Type().FriendlyName()}
 	}
 
 	depPath := val.AsString()

internal/hclparse/autoinclude_test.go

@@ -61,6 +61,42 @@ dependency "vpc" {
 	assert.NotNil(t, result.RawBody)
 }
 
+// dependency block with zero labels must be reported as a diagnostic (not silently skipped) so users learn the labelling convention.
+func TestAutoIncludeHCL_Resolve_RejectsZeroLabels(t *testing.T) {
+	t.Parallel()
+
+	body := parseHCLBody(t, `
+dependency {
+  config_path = "../vpc"
+}
+`)
+
+	autoInclude := &hclparse.AutoIncludeHCL{Remain: body}
+
+	result, diags := autoInclude.Resolve(&hcl.EvalContext{Variables: map[string]cty.Value{}})
+	assert.Nil(t, result)
+	require.True(t, diags.HasErrors())
+	assert.Contains(t, diags.Error(), "exactly one label, got 0")
+}
+
+// dependency block with two or more labels likewise produces a diagnostic instead of silently using only the first label.
+func TestAutoIncludeHCL_Resolve_RejectsTwoLabels(t *testing.T) {
+	t.Parallel()
+
+	body := parseHCLBody(t, `
+dependency "vpc" "extra" {
+  config_path = "../vpc"
+}
+`)
+
+	autoInclude := &hclparse.AutoIncludeHCL{Remain: body}
+
+	result, diags := autoInclude.Resolve(&hcl.EvalContext{Variables: map[string]cty.Value{}})
+	assert.Nil(t, result)
+	require.True(t, diags.HasErrors())
+	assert.Contains(t, diags.Error(), "exactly one label, got 2")
+}
+
 func TestAutoIncludeHCL_Resolve_MultipleDependencies(t *testing.T) {
 	t.Parallel()
 
@@ -303,7 +339,7 @@ func TestAutoIncludeDependencyPaths_MalformedReturnsTypedError(t *testing.T) {
 			name:           "non-string config_path",
 			content:        `dependency "x" { config_path = 42 }`,
 			wantDepName:    "x",
-			wantReasonPart: "config_path must be a known string literal",
+			wantReasonPart: "config_path must be a string, got number",
 		},
 		{
 			name:           "unevaluable config_path",
@@ -314,7 +350,7 @@ func TestAutoIncludeDependencyPaths_MalformedReturnsTypedError(t *testing.T) {
 		{
 			name:           "no labels",
 			content:        `dependency { config_path = "../vpc" }`,
-			wantDepName:    "<unlabeled>",
+			wantDepName:    "(unlabeled)",
 			wantReasonPart: "exactly one label, got 0",
 		},
 		{
@@ -334,7 +370,7 @@ func TestAutoIncludeDependencyPaths_MalformedReturnsTypedError(t *testing.T) {
 
 			paths, err := hclparse.AutoIncludeDependencyPaths(fs, "/test")
 			require.Error(t, err)
-			assert.Empty(t, paths, "no valid dependency paths in this fixture")
+			assert.Nil(t, paths)
 
 			var malformedErr hclparse.MalformedDependencyError
 			require.ErrorAs(t, err, &malformedErr)
@@ -345,6 +381,28 @@ func TestAutoIncludeDependencyPaths_MalformedReturnsTypedError(t *testing.T) {
 	}
 }
 
+// Mixed-case fixture: one valid dependency + one malformed. Strict contract: producer returns (nil, err) on any malformed block — no partial paths.
+func TestAutoIncludeDependencyPaths_MixedValidAndMalformed(t *testing.T) {
+	t.Parallel()
+
+	fs := vfs.NewMemMapFS()
+	require.NoError(t, vfs.WriteFile(fs, filepath.Join("/test", hclparse.AutoIncludeFile), []byte(`
+dependency "vpc" {
+  config_path = "../vpc"
+}
+
+dependency "broken" {}
+`), 0644))
+
+	paths, err := hclparse.AutoIncludeDependencyPaths(fs, "/test")
+	require.Error(t, err)
+	assert.Nil(t, paths, "strict fail-fast: no partial paths when any block is malformed")
+
+	var malformedErr hclparse.MalformedDependencyError
+	require.ErrorAs(t, err, &malformedErr)
+	assert.Equal(t, "broken", malformedErr.Name)
+}
+
 // parseHCLBody is a test helper that parses an HCL string and returns the body.
 func parseHCLBody(t *testing.T, src string) hcl.Body {
 	t.Helper()

internal/hclparse/errors.go

@@ -134,9 +134,9 @@ 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. Wrapped optionally carries the original HCL diagnostics so callers can extract position info via errors.As/Is.
+// MalformedDependencyError indicates a dependency block in an autoinclude file is malformed. Err optionally carries the original HCL diagnostics so callers can extract position info via errors.As/Is.
 type MalformedDependencyError struct {
-	Wrapped  error
+	Err      error
 	FilePath string
 	Name     string
 	Reason   string
@@ -147,5 +147,5 @@ func (e MalformedDependencyError) Error() string {
 }
 
 func (e MalformedDependencyError) Unwrap() error {
-	return e.Wrapped
+	return e.Err
 }

internal/hclparse/parse.go

@@ -334,7 +334,9 @@ func mergeOneInclude(fs vfs.FS, stackFile *StackFileHCL, inc *StackIncludeHCL, s
 	return nil
 }
 
-// recordAutoIncludeSources adds entries to srcByAutoInclude mapping each AutoInclude pointer in stackFile to src. Called once for the root stack file and once per included file so each block knows which file it was parsed from.
+// recordAutoIncludeSources maps each AutoInclude pointer in stackFile to the bytes of the file it was parsed from.
+//
+// Pointer-keying invariant: every *AutoIncludeHCL in the slice trees must be a unique allocation that is never copied into a value receiver, since the lookup at resolution time uses pointer identity. gohcl.DecodeBody satisfies this because it allocates a fresh struct for each block; only direct construction by callers would risk duplicate keys.
 func recordAutoIncludeSources(srcByAutoInclude map[*AutoIncludeHCL][]byte, stackFile *StackFileHCL, src []byte) {
 	for _, u := range stackFile.Units {
 		if u != nil && u.AutoInclude != nil {

internal/hclparse/stack.go

@@ -3,7 +3,6 @@ package hclparse
 import (
 	iofs "io/fs"
 	"path/filepath"
-	"syscall"
 
 	"github.com/gruntwork-io/terragrunt/internal/errors"
 	"github.com/gruntwork-io/terragrunt/internal/util"
@@ -154,14 +153,14 @@ func ExtractStackRefs(stacks []*StackBlockHCL) []ComponentRef {
 }
 
 // ParseStackFileFromPath reads stackDir/terragrunt.stack.hcl from disk and performs a two-pass parse.
-// Returns (nil, nil) when no stack file is reachable: file missing, or stackDir is itself a regular file (ENOTDIR).
+// Returns (nil, nil) only when the stack file does not exist. Callers that may pass non-directory paths must filter those before calling.
 func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error) {
 	stackDir = util.ResolvePath(stackDir)
 	stackFile := filepath.Join(stackDir, "terragrunt.stack.hcl")
 
 	data, err := vfs.ReadFile(fs, stackFile)
 	if err != nil {
-		if errors.Is(err, iofs.ErrNotExist) || errors.Is(err, syscall.ENOTDIR) {
+		if errors.Is(err, iofs.ErrNotExist) {
 			return nil, nil
 		}
 

internal/hclparse/stack_test.go

@@ -339,16 +339,16 @@ func TestParseStackFileFromPath_NoFile(t *testing.T) {
 	assert.Nil(t, result)
 }
 
-// Discovery callers may pass an arbitrary dependency path that is itself a regular file (e.g. another-name.hcl); ENOTDIR must be treated like a missing stack file, not a hard error.
-func TestParseStackFileFromPath_StackDirIsFile(t *testing.T) {
+// ParseStackFileFromPath is strict: passing a regular file produces an error. Callers that may receive non-directory paths (e.g. discovery) must filter them upstream.
+func TestParseStackFileFromPath_StackDirIsFileReturnsError(t *testing.T) {
 	t.Parallel()
 
 	tmpDir := t.TempDir()
 	filePath := filepath.Join(tmpDir, "another-name.hcl")
 	require.NoError(t, os.WriteFile(filePath, []byte(`# regular file, not a directory`), 0644))
 
 	result, err := hclparse.ParseStackFileFromPath(vfs.NewOSFS(), filePath)
-	require.NoError(t, err)
+	require.Error(t, err)
 	assert.Nil(t, result)
 }
 

pkg/config/stack.go

@@ -396,13 +396,7 @@ func generateAutoInclude(l log.Logger, opts *generateOpts, cmp *componentToGener
 
 	l.Infof("Generating %s for %s %s", inthclparse.AutoIncludeFile, kindStr, cmp.name)
 
-	// Use the resolved autoinclude's own source bytes; falling back to root stack bytes when unset preserves prior behavior for non-include flows.
-	srcBytes := resolved.SourceBytes
-	if srcBytes == nil {
-		srcBytes = opts.stackSrcBytes
-	}
-
-	if err := inthclparse.GenerateAutoIncludeFile(vfs.NewOSFS(), resolved, dest, srcBytes, resolved.EvalCtx); err != nil {
+	if err := inthclparse.GenerateAutoIncludeFile(vfs.NewOSFS(), resolved, dest, resolved.SourceBytes, resolved.EvalCtx); err != nil {
 		return errors.Errorf("failed to write autoinclude for %s %s: %w", kindStr, cmp.name, err)
 	}
 

pkg/config/stack_autoinclude_internal_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStackConfigHasAutoInclude(t *testing.T) {
@@ -69,7 +70,7 @@ func parseSyntaxBody(t *testing.T, src string) hcl.Body {
 	t.Helper()
 
 	file, diags := hclsyntax.ParseConfig([]byte(src), "test.hcl", hcl.Pos{Line: 1, Column: 1})
-	assert.False(t, diags.HasErrors(), "parse: %s", diags)
+	require.False(t, diags.HasErrors(), "parse: %s", diags)
 
 	return file.Body
 }