chore: panic updates

Author: denis256

internal/hclparse/autoinclude.go

@@ -182,11 +182,11 @@ func BuildAutoIncludeEvalContext(unitRefs, stackRefs []ComponentRef) *hcl.EvalCo
 // Returns (nil, nil) if the file does not exist or has no dependencies.
 func AutoIncludeDependencyPaths(fs vfs.FS, unitDir string) ([]string, error) {
 	if fs == nil {
-		panic(fmt.Sprintf("hclparse.AutoIncludeDependencyPaths: fs is nil; a vfs.FS is required to read the generated %s file and extract dependency paths for DAG construction (unitDir=%q)", AutoIncludeFile, unitDir))
+		panic(fmt.Sprintf("hclparse.AutoIncludeDependencyPaths: fs is nil (unitDir=%q)", unitDir))
 	}
 
 	if unitDir == "" {
-		panic(fmt.Sprintf("hclparse.AutoIncludeDependencyPaths: unitDir is empty (got %q); unitDir must be the generated unit directory containing %s", unitDir, AutoIncludeFile))
+		panic("hclparse.AutoIncludeDependencyPaths: unitDir is empty")
 	}
 
 	unitDir = util.ResolvePath(unitDir)

internal/hclparse/generate.go

@@ -37,11 +37,11 @@ const (
 // source text for expressions via byte ranges.
 func GenerateAutoIncludeFile(fs vfs.FS, resolved *AutoIncludeResolved, targetDir string, srcBytes []byte, evalCtx *hcl.EvalContext) error {
 	if fs == nil {
-		panic(fmt.Sprintf("hclparse.GenerateAutoIncludeFile: fs is nil; a vfs.FS is required to create targetDir and write the generated autoinclude file (targetDir=%q)", targetDir))
+		panic(fmt.Sprintf("hclparse.GenerateAutoIncludeFile: fs is nil (targetDir=%q, sourceFile=%q)", targetDir, resolvedSourceFile(resolved)))
 	}
 
 	if targetDir == "" {
-		panic(fmt.Sprintf("hclparse.GenerateAutoIncludeFile: targetDir is empty (got %q); targetDir is the generated unit directory where %s will be written", targetDir, AutoIncludeFile))
+		panic(fmt.Sprintf("hclparse.GenerateAutoIncludeFile: targetDir is empty (sourceFile=%q)", resolvedSourceFile(resolved)))
 	}
 
 	if resolved == nil {
@@ -252,3 +252,14 @@ func writeNonDependencyContent(outBody *hclwrite.Body, body *hclsyntax.Body, src
 func quotedStringTokens(value string) hclwrite.Tokens {
 	return hclwrite.TokensForValue(cty.StringVal(value))
 }
+
+// resolvedSourceFile extracts the originating HCL filename from a resolved
+// autoinclude, used to enrich panic messages with file context. Returns ""
+// when resolved or its body is nil.
+func resolvedSourceFile(resolved *AutoIncludeResolved) string {
+	if resolved == nil || resolved.RawBody == nil {
+		return ""
+	}
+
+	return resolved.RawBody.MissingItemRange().Filename
+}

internal/hclparse/parse.go

@@ -68,15 +68,15 @@ func ParseStackFile(fs vfs.FS, input *ParseStackFileInput) (*ParseResult, error)
 			filename = input.Filename
 		}
 
-		panic(fmt.Sprintf("hclparse.ParseStackFile: fs is nil; a vfs.FS is required to read included stack files (e.g. pass vfs.NewOSFS() for disk or vfs.NewMemMapFS() for tests) (filename=%q)", filename))
+		panic(fmt.Sprintf("hclparse.ParseStackFile: fs is nil (filename=%q)", filename))
 	}
 
 	if input == nil {
-		panic("hclparse.ParseStackFile: input is nil; caller must provide a *ParseStackFileInput with Src and StackDir set")
+		panic("hclparse.ParseStackFile: input is nil")
 	}
 
 	if input.StackDir == "" {
-		panic(fmt.Sprintf("hclparse.ParseStackFile: input.StackDir is empty (got %q); StackDir is required to resolve relative include paths and compute generated unit directories (filename=%q)", input.StackDir, input.Filename))
+		panic(fmt.Sprintf("hclparse.ParseStackFile: input.StackDir is empty (filename=%q)", input.Filename))
 	}
 
 	file, diags := hclsyntax.ParseConfig(input.Src, input.Filename, hcl.Pos{Line: 1, Column: 1})

internal/hclparse/stack.go

@@ -157,11 +157,11 @@ func ExtractStackRefs(stacks []*StackBlockHCL) []ComponentRef {
 // and performs a two-pass parse. Returns nil, nil if the file does not exist.
 func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error) {
 	if fs == nil {
-		panic(fmt.Sprintf("hclparse.ParseStackFileFromPath: fs is nil; a vfs.FS is required to read terragrunt.stack.hcl from disk (pass vfs.NewOSFS() or vfs.NewMemMapFS()) (stackDir=%q)", stackDir))
+		panic(fmt.Sprintf("hclparse.ParseStackFileFromPath: fs is nil (stackDir=%q)", stackDir))
 	}
 
 	if stackDir == "" {
-		panic(fmt.Sprintf("hclparse.ParseStackFileFromPath: stackDir is empty (got %q); stackDir is required to locate terragrunt.stack.hcl and resolve include paths", stackDir))
+		panic("hclparse.ParseStackFileFromPath: stackDir is empty")
 	}
 
 	stackDir = util.ResolvePath(stackDir)
@@ -188,11 +188,11 @@ func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error) {
 // Returns nil if the file does not exist or cannot be parsed.
 func UnitPathsFromStackDir(fs vfs.FS, stackDir string) []string {
 	if fs == nil {
-		panic(fmt.Sprintf("hclparse.UnitPathsFromStackDir: fs is nil; a vfs.FS is required to read the stack file and enumerate its generated unit directories (stackDir=%q)", stackDir))
+		panic(fmt.Sprintf("hclparse.UnitPathsFromStackDir: fs is nil (stackDir=%q)", stackDir))
 	}
 
 	if stackDir == "" {
-		panic(fmt.Sprintf("hclparse.UnitPathsFromStackDir: stackDir is empty (got %q); stackDir is required to locate terragrunt.stack.hcl and compute generated unit paths", stackDir))
+		panic("hclparse.UnitPathsFromStackDir: stackDir is empty")
 	}
 
 	stackDir = util.ResolvePath(stackDir)
@@ -229,15 +229,15 @@ const maxDiscoverDepth = 1000
 // stack's units will be generated (.terragrunt-stack/stack_path/).
 func DiscoverStackChildUnits(fs vfs.FS, stackSourceDir, stackGenDir string) []ComponentRef {
 	if fs == nil {
-		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: fs is nil; a vfs.FS is required to read the nested stack's terragrunt.stack.hcl (stackSourceDir=%q, stackGenDir=%q)", stackSourceDir, stackGenDir))
+		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: fs is nil (stackSourceDir=%q, stackGenDir=%q)", stackSourceDir, stackGenDir))
 	}
 
 	if stackSourceDir == "" {
-		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: stackSourceDir is empty (got %q); this is the directory containing the nested stack's source terragrunt.stack.hcl (stackGenDir=%q)", stackSourceDir, stackGenDir))
+		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: stackSourceDir is empty (stackGenDir=%q)", stackGenDir))
 	}
 
 	if stackGenDir == "" {
-		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: stackGenDir is empty (got %q); this is the target directory where the nested stack's units will be generated (stackSourceDir=%q)", stackGenDir, stackSourceDir))
+		panic(fmt.Sprintf("hclparse.DiscoverStackChildUnits: stackGenDir is empty (stackSourceDir=%q)", stackSourceDir))
 	}
 
 	return discoverStackChildUnitsWithDepth(fs, stackSourceDir, stackGenDir, 0)