hclparse

type AutoIncludeDependency ¶

type AutoIncludeDependency struct {
	// Block is the original HCL block, preserved for serialization.
	Block      *hcl.Block
	Name       string
	ConfigPath string
}

AutoIncludeDependency represents a resolved dependency block from autoinclude. config_path has been evaluated (e.g. unit.vpc.path → "/abs/path/to/.terragrunt-stack/vpc"). The original HCL block is preserved for writing all attributes (mock_outputs, etc.) into the generated file.

type AutoIncludeHCL ¶

type AutoIncludeHCL struct {
	Remain hcl.Body `hcl:",remain"`
}

AutoIncludeHCL represents the first-phase parse of an autoinclude block. The entire body is captured as remain because it may contain references to unit.*.path / stack.*.path variables that are only available after the first parsing pass extracts all unit/stack names and paths.

Example HCL:

autoinclude {
  dependency "vpc" {
    config_path = unit.vpc.path
  }
  inputs = {
    vpc_id = dependency.vpc.outputs.vpc_id
  }
}

func (a *AutoIncludeHCL) Resolve(evalCtx *hcl.EvalContext) (*AutoIncludeResolved, hcl.Diagnostics)

type AutoIncludeResolved ¶

type AutoIncludeResolved struct {
	// EvalCtx is the HCL evaluation context used during resolution,
	// preserved so the generator can evaluate non-deferred expressions.
	EvalCtx *hcl.EvalContext
	// RawBody is the original autoinclude HCL body, preserved so
	// the generator can write non-dependency content (inputs, etc.)
	// directly from the AST without evaluating dependency.* references.
	RawBody      hcl.Body
	Dependencies []AutoIncludeDependency
}

AutoIncludeResolved represents the second-phase resolved autoinclude content.

After the first parse extracts unit/stack names and paths, the autoinclude body is partially evaluated:

• dependency.config_path is resolved (references unit.*.path)
• dependency remain (mock_outputs etc) is preserved for generation
• inputs and other blocks are partially evaluated (local.* resolved, dependency.* preserved)

The RawBody is preserved for serializing the generated terragrunt.autoinclude.hcl file.

type ComponentRef ¶

type ComponentRef struct {
	Name string
	Path string
	// ChildRefs holds nested unit refs for stack components.
	// When a stack block references a source with a terragrunt.stack.hcl,
	// the child units within that stack are parsed and stored here.
	// This enables stack.stack_name.unit_name.path references.
	ChildRefs []ComponentRef
}

ComponentRef holds the path and name metadata for a unit or stack block, used to build the evaluation context for the second parsing phase.

func DiscoverStackChildUnits(fs vfs.FS, stackSourceDir, stackGenDir string) []ComponentRef

func ExtractStackRefs(stacks []*StackBlockHCL) []ComponentRef

func ExtractUnitRefs(units []*UnitBlockHCL) []ComponentRef

type Copier ¶

type Copier struct {
	// contains filtered or unexported fields
}

Copier copies HCL blocks from AST source to hclwrite output. When an eval context is set, attributes are partially evaluated (local.* resolved, dependency.* preserved). Without it, attributes are copied verbatim from source bytes.

func NewCopier() *Copier

func (c *Copier) CopyBlock(outBody *hclwrite.Body, block *hclsyntax.Block, srcBytes []byte)

func (c *Copier) WithEvalCtx(evalCtx *hcl.EvalContext) *Copier

type DirCreateError ¶

type DirCreateError struct {
	Err     error
	DirPath string
}

DirCreateError indicates a failure to create a directory.

func (e DirCreateError) Error() string

func (e DirCreateError) Unwrap() error

type DuplicateStackNameError ¶

type DuplicateStackNameError struct {
	Name string
}

DuplicateStackNameError indicates that multiple stacks with the same name were found after merging include blocks.

func (e DuplicateStackNameError) Error() string

type DuplicateUnitNameError ¶

type DuplicateUnitNameError struct {
	Name string
}

DuplicateUnitNameError indicates that multiple units with the same name were found after merging include blocks.

func (e DuplicateUnitNameError) Error() string

type EvalArgs ¶

type EvalArgs struct {
	EvalCtx  *hcl.EvalContext
	Deferred map[string]bool
	SrcBytes []byte
}

EvalArgs bundles the shared arguments for partial evaluation functions.

type FileDecodeError ¶

type FileDecodeError struct {
	Name   string
	Detail string
}

FileDecodeError indicates a failure to decode an HCL file into a struct.

func (e FileDecodeError) Error() string

type FileParseError ¶

type FileParseError struct {
	FilePath string
	Detail   string
}

FileParseError indicates a failure to parse an HCL file.

func (e FileParseError) Error() string

type FileReadError ¶

type FileReadError struct {
	Err      error
	FilePath string
}

FileReadError indicates a failure to read a file from the filesystem.

func (e FileReadError) Error() string

func (e FileReadError) Unwrap() error

type FileWriteError ¶

type FileWriteError struct {
	Err      error
	FilePath string
}

FileWriteError indicates a failure to write a file to the filesystem.

func (e FileWriteError) Error() string

func (e FileWriteError) Unwrap() error

type IncludeValidationError ¶

type IncludeValidationError struct {
	IncludeName string
	Reason      string
}

IncludeValidationError indicates that an included stack file violates constraints (e.g. defines locals or nested includes).

func (e IncludeValidationError) Error() string

type LocalEvalError ¶

type LocalEvalError struct {
	Name   string
	Detail string
}

LocalEvalError indicates a failure to evaluate a local variable.

func (e LocalEvalError) Error() string

type LocalsCycleError ¶

type LocalsCycleError struct {
	Names []string
}

LocalsCycleError indicates that locals have circular dependencies.

func (e LocalsCycleError) Error() string

type LocalsHCL ¶

type LocalsHCL struct {
	Remain hcl.Body `hcl:",remain"`
}

LocalsHCL captures the locals block body for iterative evaluation.

type LocalsMaxIterError ¶

type LocalsMaxIterError struct {
	MaxIterations int
	Remaining     int
}

LocalsMaxIterError indicates that locals evaluation exceeded the maximum iterations.

func (e LocalsMaxIterError) Error() string

type ParseResult ¶

type ParseResult struct {
	// AutoIncludes maps component name → resolved autoinclude (only for units/stacks
	// that had an autoinclude block). Dependencies have config_path resolved.
	AutoIncludes map[string]*AutoIncludeResolved
	// Units from the first-pass parse (name, source, path, values decoded).
	Units []*UnitBlockHCL
	// Stacks from the first-pass parse.
	Stacks []*StackBlockHCL
}

ParseResult holds the output of a two-pass parse of a terragrunt.stack.hcl file.

func ParseStackFile(fs vfs.FS, input *ParseStackFileInput) (*ParseResult, error)

func ParseStackFileFromPath(fs vfs.FS, stackDir string) (*ParseResult, error)

type ParseStackFileInput ¶

type ParseStackFileInput struct {
	Values   *cty.Value
	Filename string
	StackDir string
	Src      []byte
}

ParseStackFileInput holds the input for ParseStackFile.

type StackBlockHCL ¶

type StackBlockHCL struct {
	AutoInclude  *AutoIncludeHCL `hcl:"autoinclude,block"`
	NoStack      *bool           `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool           `hcl:"no_validation,attr"`
	Values       *cty.Value      `hcl:"values,attr"`
	Name         string          `hcl:",label"`
	Source       string          `hcl:"source,attr"`
	Path         string          `hcl:"path,attr"`
}

StackBlockHCL represents the first-phase parse of a stack block. Same remain pattern as UnitBlockHCL.

type StackFileHCL ¶

type StackFileHCL struct {
	Locals   *LocalsHCL         `hcl:"locals,block"`
	Includes []*StackIncludeHCL `hcl:"include,block"`
	Stacks   []*StackBlockHCL   `hcl:"stack,block"`
	Units    []*UnitBlockHCL    `hcl:"unit,block"`
}

StackFileHCL represents the first-phase parse of a terragrunt.stack.hcl file. The autoinclude body inside each unit/stack block is captured as hcl.Body via remain, allowing deferred evaluation once unit/stack path variables are available.

type StackIncludeHCL ¶

type StackIncludeHCL struct {
	Name string `hcl:",label"`
	Path string `hcl:"path,attr"`
}

StackIncludeHCL represents an include block in a terragrunt.stack.hcl file. The path is evaluated immediately during the first parse pass.

type UnexpectedBodyTypeError ¶

type UnexpectedBodyTypeError struct {
	FilePath string
}

UnexpectedBodyTypeError indicates that an HCL file body was not the expected *hclsyntax.Body type. This typically occurs with JSON-format HCL files.

func (e UnexpectedBodyTypeError) Error() string

type UnitBlockHCL ¶

type UnitBlockHCL struct {
	AutoInclude  *AutoIncludeHCL `hcl:"autoinclude,block"`
	NoStack      *bool           `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool           `hcl:"no_validation,attr"`
	Values       *cty.Value      `hcl:"values,attr"`
	Name         string          `hcl:",label"`
	Source       string          `hcl:"source,attr"`
	Path         string          `hcl:"path,attr"`
}

UnitBlockHCL represents the first-phase parse of a unit block. Known attributes are decoded directly. The autoinclude block body is captured in Remain for second-phase evaluation.