add stack values generation

config/config.go

@@ -79,7 +79,6 @@ const (
 	MetadataErrors                      = "errors"
 	MetadataRetry                       = "retry"
 	MetadataIgnore                      = "ignore"
-	MetadataUnit                        = "unit"
 	MetadataValues                      = "values"
 )
 
@@ -895,6 +894,13 @@ func ParseConfig(ctx *ParsingContext, file *hclparse.File, includeFromChild *Inc
 		return nil, err
 	}
 
+	// read unit files and add to context
+	unitValues, err := ReadUnitValues(ctx.Context, ctx.TerragruntOptions, filepath.Dir(file.ConfigPath))
+	if err != nil {
+		return nil, err
+	}
+	ctx = ctx.WithValues(unitValues)
+
 	// Decode just the Base blocks. See the function docs for DecodeBaseBlocks for more info on what base blocks are.
 	baseBlocks, err := DecodeBaseBlocks(ctx, file, includeFromChild)
 	if err != nil {

config/config_helpers.go

@@ -210,6 +210,10 @@ func createTerragruntEvalContext(ctx *ParsingContext, configPath string) (*hcl.E
 		evalCtx.Variables[MetadataFeatureFlag] = *ctx.Features
 	}
 
+	if ctx.Values != nil {
+		evalCtx.Variables[MetadataValues] = *ctx.Values
+	}
+
 	if ctx.DecodedDependencies != nil {
 		evalCtx.Variables[MetadataDependency] = *ctx.DecodedDependencies
 	}
@@ -225,15 +229,6 @@ func createTerragruntEvalContext(ctx *ParsingContext, configPath string) (*hcl.E
 		evalCtx.Variables[MetadataInclude] = exposedInclude
 	}
 
-	// read unit files and add to context
-	unitValues, err := ReadUnitValues(ctx.Context, ctx.TerragruntOptions, filepath.Dir(configPath))
-	if err != nil {
-		return evalCtx, err
-	}
-	if unitValues != nil {
-		evalCtx.Variables[MetadataValues] = cty.ObjectVal(unitValues)
-	}
-
 	return evalCtx, nil
 }
 

config/config_partial.go

@@ -346,6 +346,13 @@ func PartialParseConfigString(ctx *ParsingContext, configPath, configString stri
 func PartialParseConfig(ctx *ParsingContext, file *hclparse.File, includeFromChild *IncludeConfig) (*TerragruntConfig, error) {
 	ctx = ctx.WithTrackInclude(nil)
 
+	// read unit files and add to context
+	unitValues, err := ReadUnitValues(ctx.Context, ctx.TerragruntOptions, filepath.Dir(file.ConfigPath))
+	if err != nil {
+		return nil, err
+	}
+	ctx = ctx.WithValues(unitValues)
+
 	// Decode just the Base blocks. See the function docs for DecodeBaseBlocks for more info on what base blocks are.
 	// Initialize evaluation ctx extensions from base blocks.
 	baseBlocks, err := DecodeBaseBlocks(ctx, file, includeFromChild)

config/locals.go

@@ -182,8 +182,8 @@ func canEvaluateLocals(expression hcl.Expression, evaluatedLocals map[string]cty
 		case rootName == MetadataFeatureFlag:
 			// If the variable is `feature`
 
-		case rootName == MetadataUnit:
-			// If the variable is `unit`
+		case rootName == MetadataValues:
+			// If the variable is `values`
 
 		case rootName != "local":
 			// We can't evaluate any variable other than `local`

config/parsing_context.go

@@ -27,6 +27,9 @@ type ParsingContext struct {
 	// Features are the feature flags that are enabled for the current terragrunt config.
 	Features *cty.Value
 
+	// Values of the unit
+	Values *cty.Value
+
 	// DecodedDependencies are references of other terragrunt config. This contains the following attributes that map to
 	// various fields related to that config:
 	// - outputs: The map of outputs from the terraform state obtained by running `terragrunt output` on that target config.
@@ -72,6 +75,11 @@ func (ctx ParsingContext) WithLocals(locals *cty.Value) *ParsingContext {
 	return &ctx
 }
 
+func (ctx ParsingContext) WithValues(values *cty.Value) *ParsingContext {
+	ctx.Values = values
+	return &ctx
+}
+
 // WithFeatures sets the feature flags to be used in evaluation context.
 func (ctx ParsingContext) WithFeatures(features *cty.Value) *ParsingContext {
 	ctx.Features = features

config/stack.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 
 	"github.com/gruntwork-io/terragrunt/util"
-	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclwrite"
 
 	"github.com/zclconf/go-cty/cty"
@@ -114,28 +113,30 @@ func WriteUnitValues(opts *options.TerragruntOptions, unit *Unit, unitDirectory
 }
 
 // ReadUnitValues reads the unit values from the terragrunt.values.hcl file.
-func ReadUnitValues(ctx context.Context, opts *options.TerragruntOptions, unitDirectory string) (map[string]cty.Value, error) {
+func ReadUnitValues(ctx context.Context, opts *options.TerragruntOptions, unitDirectory string) (*cty.Value, error) {
 	filePath := filepath.Join(unitDirectory, unitValuesFile)
-	if !util.FileNotExists(filePath) {
+	if util.FileNotExists(filePath) {
 		return nil, nil
 	}
 	opts.Logger.Debugf("Reading Terragrunt stack values file at %s", filePath)
 
 	parser := NewParsingContext(ctx, opts)
 
-	file, err := hclparse.NewParser(parser.ParserOptions...).ParseFromFile(opts.TerragruntStackConfigPath)
+	file, err := hclparse.NewParser(parser.ParserOptions...).ParseFromFile(filePath)
 	if err != nil {
 		return nil, errors.New(err)
 	}
-	// empty eval context to parse values only
-	evalCtx := &hcl.EvalContext{
-		Variables: map[string]cty.Value{},
+	evalParsingContext, err := createTerragruntEvalContext(parser, file.ConfigPath)
+	if err != nil {
+		return nil, errors.New(err)
 	}
+	// empty eval context to parse values only
 	values := map[string]cty.Value{}
-	if err := file.Decode(&values, evalCtx); err != nil {
+	if err := file.Decode(&values, evalParsingContext); err != nil {
 		return nil, errors.New(err)
 	}
-	return values, nil
+	result := cty.ObjectVal(values)
+	return &result, nil
 }
 
 // ValidateStackConfig validates a StackConfigFile instance according to the rules: