hcl2

func AllowMissingVariables ¶ added in v2.2.0

func AllowMissingVariables(options *bindOptions)

func DecomposeToken ¶

func DecomposeToken(tok string, sourceRange hcl.Range) (string, string, string, hcl.Diagnostics)

func GetSchemaForType ¶ added in v2.2.0

func GetSchemaForType(t model.Type) (schema.Type, bool)

GetSchemaForType extracts the schema.Type associated with a model.Type, if any.

The result may be a *schema.UnionType if multiple schema types are associated with the input type.

func NewApplyCall ¶

func NewApplyCall(args []model.Expression, then *model.AnonymousFunctionExpression) *model.FunctionCallExpression

NewApplyCall returns a new expression that represents a call to IntrinsicApply.

func NewConvertCall ¶ added in v2.2.0

func NewConvertCall(from model.Expression, to model.Type) *model.FunctionCallExpression

NewConvertCall returns a new expression that represents a call to IntrinsicConvert.

func ParseApplyCall ¶

func ParseApplyCall(c *model.FunctionCallExpression) (applyArgs []model.Expression,
	then *model.AnonymousFunctionExpression)

ParseApplyCall extracts the apply arguments and the continuation from a call to the apply intrinsic.

func ParseConvertCall ¶ added in v2.2.0

func ParseConvertCall(c *model.FunctionCallExpression) (model.Expression, model.Type)

ParseConvertCall extracts the value being converted and the type it is being converted to from a call to the convert intrinsic.

func RewriteApplies ¶

func RewriteApplies(expr model.Expression, nameInfo NameInfo, applyPromises bool) (model.Expression, hcl.Diagnostics)

RewriteApplies transforms all expressions that observe the resolved values of outputs and promises into calls to the __apply intrinsic. Expressions that generate or inspect outputs or promises are passed as arguments to these calls, and are replaced by references to the corresponding parameter.

As an example, assuming that resource.id is an output, this transforms the following expression:

toJSON({
    Version = "2012-10-17"
    Statement = [{
        Effect = "Allow"
        Principal = "*"
        Action = [ "s3:GetObject" ]
        Resource = [ "arn:aws:s3:::${resource.id}/*" ]
    }]
})

into this expression:

__apply(resource.id, eval(id, toJSON({
    Version = "2012-10-17"
    Statement = [{
        Effect = "Allow"
        Principal = "*"
        Action = [ "s3:GetObject" ]
        Resource = [ "arn:aws:s3:::${id}/*" ]
    }]
})))

Here is a more advanced example, assuming that resource is an object whose properties are all outputs, this expression:

"v: ${resource[resource.id]}"

is transformed into this expression:

__apply(__apply(resource.id,eval(id, resource[id])),eval(id, "v: ${id}"))

This form is amenable to code generation for targets that require that outputs are resolved before their values are accessible (e.g. Pulumi's JS/TS libraries).

func RewriteConversions ¶ added in v2.2.0

func RewriteConversions(x model.Expression, to model.Type) model.Expression

RewriteConversions wraps automatic conversions indicated by the HCL2 spec and conversions to schema-annotated types in calls to the __convert intrinsic.

Note that the result is a bit out of line with the HCL2 spec, as static conversions may happen earlier than they would at runtime. For example, consider the case of a tuple of strings that is being converted to a list of numbers:

[a, b, c]

Calling RewriteConversions on this expression with a destination type of list(number) would result in this IR:

[__convert(a), __convert(b), __convert(c)]

If any of these conversions fail, the evaluation of the tuple itself fails. The HCL2 evaluation semantics, however, would convert the tuple _after_ it has been evaluated. The IR that matches these semantics is

__convert([a, b, c])

This transform uses the former representation so that it can appropriately insert calls to `__convert` in the face of schema-annotated types. There is a reasonable argument to be made that RewriteConversions should not be responsible for propagating schema annotations, and that this pass should be split in two: one pass would insert conversions that match HCL2 evaluation semantics, and another would insert calls to some separate intrinsic in order to propagate schema information.

func RewritePropertyReferences ¶ added in v2.6.0

func RewritePropertyReferences(expr model.Expression) model.Expression