pcl

func AllowMissingProperties ¶

func AllowMissingProperties(options *bindOptions)

func AllowMissingVariables ¶

func AllowMissingVariables(options *bindOptions)

func AnnotateAttributeValue ¶ added in v3.43.0

func AnnotateAttributeValue(expr model.Expression, attributeType schema.Type) model.Expression

func AnnotateResourceInputs ¶ added in v3.43.0

func AnnotateResourceInputs(node *Resource)

func DecomposeToken ¶

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

func EnumMember ¶ added in v3.30.0

func EnumMember(t *model.EnumType, value cty.Value) (*schema.Enum, bool)

EnumMember returns the name of the member that matches the given `value`. If no member if found, (nil, true) returned. If the query is nonsensical, either because no schema is associated with the EnumMember or if the type of value mismatches the type of the schema, (nil, false) is returned.

func FixupPulumiPackageTokens ¶ added in v3.39.0

func FixupPulumiPackageTokens(r *Resource)

func GenEnum ¶ added in v3.30.0

func GenEnum(
	t *model.EnumType,
	from model.Expression,
	safeEnum func(member *schema.Enum),
	unsafeEnum func(from model.Expression),
)

GenEnum is a helper function when generating an enum. Given an enum, and instructions on what to do when you find a known value, and an unknown value, return a function that will generate an the given enum from the given expression.

This function should probably live in the `codegen` namespace, but cannot because of import cycles.

func GetDiscriminatedUnionObjectMapping ¶

func GetDiscriminatedUnionObjectMapping(t *model.UnionType) map[string]model.Type

GetDiscriminatedUnionObjectMapping calculates a map of type names to object types for a given union type.

func GetSchemaForType ¶

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 IsOutputVersionInvokeCall ¶ added in v3.18.0

func IsOutputVersionInvokeCall(call *model.FunctionCallExpression) bool

Detects invoke calls that use an output version of a function.

func LowerConversion ¶ added in v3.30.0

func LowerConversion(from model.Expression, to model.Type) model.Type

LowerConversion lowers a conversion for a specific value, such that converting `from` to a value of the returned type will produce valid code. The algorithm prioritizes safe conversions over unsafe conversions. If no conversion can be found, nil, false is returned.

This is useful because it cuts out conversion steps which the caller doesn't need to worry about. For example: Given inputs

from = string("foo") # a constant string with value "foo"
to = union(enum(string: "foo", "bar"), input(enum(string: "foo", "bar")), none)

We would receive output type:

enum(string: "foo", "bar")

since the caller can convert string("foo") to the enum directly, and does not need to consider the union.

For another example consider inputs:

from = var(string) # A variable of type string
to = union(enum(string: "foo", "bar"), string)

We would return type:

string

since var(string) can be safely assigned to string, but unsafely assigned to enum(string: "foo", "bar").

func MapProvidersAsResources ¶ added in v3.37.0

func MapProvidersAsResources(p *Program)

Remaps the "pulumi:providers:$Package" token style to "$Package:index:Provider", consistent with code generation. This mapping is consistent with how provider resources are projected into the schema and removes special casing logic to generate registering explicit providers.

The resultant program should be a shallow copy of the source with only the modified resource nodes copied.

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 ¶

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 ¶

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 RecognizeOutputVersionedInvoke ¶ added in v3.18.0

func RecognizeOutputVersionedInvoke(
	expr *model.FunctionCallExpression,
) (bool, *model.ObjectConsExpression, model.Type)

Pattern matches to recognize an encoded call to an output-versioned invoke, such as `invoke(token, __convert(objCons(..)))`. If matching, returns the `args` expression and its schema-bound type.

func RecognizeTypedObjectCons ¶ added in v3.18.0

func RecognizeTypedObjectCons(theExpr model.Expression) (bool, *model.ObjectConsExpression, model.Type)

Pattern matches to recognize `__convert(objCons(..))` pattern that is used to annotate object constructors with appropriate nominal types. If the expression matches, returns true followed by the constructor expression and the appropriate type.

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 ¶

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

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 ¶

func RewritePropertyReferences(expr model.Expression) model.Expression

func SkipResourceTypechecking ¶

func SkipResourceTypechecking(options *bindOptions)