@cdktn/hcl2cdk 0.21.0

package/lib/expressions.js

@@ -0,0 +1,634 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicVariableToAst = exports.extractIteratorVariablesFromExpression = exports.convertTerraformExpressionToTs = exports.expressionAst = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const t = __importStar(require("@babel/types"));
+const template_1 = __importDefault(require("@babel/template"));
+const utils_1 = require("./utils");
+const hcl2json_1 = require("@cdktn/hcl2json");
+const hcl2json_2 = require("@cdktn/hcl2json");
+const functions_1 = require("./function-bindings/functions");
+const coerceType_1 = require("./coerceType");
+const terraformSchema_1 = require("./terraformSchema");
+const references_1 = require("./references");
+const variables_1 = require("./variables");
+const syntax_tree_1 = require("@cdktn/hcl2json/lib/syntax-tree");
+const tfBinaryOperatorsToCdktf = {
+    logicalOr: "or",
+    logicalAnd: "and",
+    greaterThan: "gt",
+    greaterThanOrEqual: "gte",
+    lessThan: "lt",
+    lessThanOrEqual: "lte",
+    equal: "eq",
+    notEqual: "neq",
+    add: "add",
+    subtract: "sub",
+    multiply: "mul",
+    divide: "div",
+    modulo: "mod",
+};
+const tfUnaryOperatorsToCdktf = {
+    logicalNot: "not",
+    negate: "negate",
+};
+function traversalPartsToString(traversals, asSuffix = false) {
+    let seed = "";
+    if (asSuffix && hcl2json_2.TFExpressionSyntaxTree.isNameTraversalPart(traversals[0])) {
+        seed = ".";
+    }
+    return traversals.reduce((acc, part) => {
+        if (part.type === "nameTraversal") {
+            if (acc === seed) {
+                return `${acc}${part.segment}`;
+            }
+            return `${acc}.${part.segment}`;
+        }
+        return `${acc}[${part.segment}]`;
+    }, seed);
+}
+function canUseFqn(expression) {
+    if (!hcl2json_2.TFExpressionSyntaxTree.isScopeTraversalExpression(expression)) {
+        return false;
+    }
+    const rootSegment = expression.meta.traversal[0].segment;
+    return !["var", "local"].includes(rootSegment);
+}
+function traversalToVariableName(scope, node) {
+    if (!hcl2json_2.TFExpressionSyntaxTree.isScopeTraversalExpression(node)) {
+        utils_1.logger.error(`Unexpected expression type ${node.type} with value ${node.meta.value} passed to convert to a variable. 
+        ${utils_1.leaveCommentText}`);
+        return "";
+    }
+    const segments = node.meta.traversal;
+    if (segments.length === 1) {
+        return node.meta.fullAccessor;
+    }
+    const rootSegment = segments[0].segment;
+    const resource = rootSegment === "data"
+        ? `${segments[0].segment}.${segments[1].segment}`
+        : rootSegment;
+    const name = rootSegment === "data" ? segments[2].segment : segments[1].segment;
+    return (0, variables_1.variableName)(scope, resource, name);
+}
+function expressionForSerialStringConcatenation(scope, nodes) {
+    const reducedNodes = nodes.reduce((acc, node) => {
+        const prev = acc[acc.length - 1];
+        if (!prev)
+            return [node];
+        if (t.isStringLiteral(prev) && t.isStringLiteral(node)) {
+            acc.pop();
+            acc.push(t.stringLiteral(prev.value + node.value));
+            return acc;
+        }
+        acc.push(node);
+        return acc;
+    }, []);
+    return reducedNodes.reduce((acc, node) => {
+        if (!acc) {
+            return node;
+        }
+        // wrap access to dynamic blocks in Token.asString() as they return a Lazy
+        // for .key and .value which can't be concatenated in languages like Python
+        // because JSII currently has no support for the toString() method in
+        // languages other than TypeScript: https://github.com/aws/jsii/issues/380
+        // example: dynamic_iterator0.key / dynamic_iterator0.value
+        if (t.isMemberExpression(node) &&
+            t.isIdentifier(node.object) &&
+            Object.values(scope.scopedVariables || {}).includes(node.object.name) &&
+            t.isIdentifier(node.property) &&
+            ["key", "value"].includes(node.property.name)) {
+            node = (0, coerceType_1.coerceType)(scope, node, "dynamic", "string");
+        }
+        return t.binaryExpression("+", acc, node);
+    });
+}
+function getTfResourcePathFromNode(node) {
+    const segments = node.meta.traversal;
+    let resource = segments[0].segment;
+    let result = [];
+    let attributes = [];
+    if (segments[0].segment === "data") {
+        result.push(segments[0].segment);
+        resource = segments[1].segment;
+        attributes = segments.slice(3); // we want to skip the variable name
+    }
+    else {
+        attributes = segments.slice(2); // we want to skip the variable name
+    }
+    const [provider, ...resourceNameFragments] = resource.split("_");
+    // Hack: This happens in the case of `external` provider
+    // where the data source does not have a provider name prefix
+    if (resourceNameFragments.length === 0) {
+        resourceNameFragments.push(provider);
+    }
+    result.push(provider);
+    result.push(resourceNameFragments.join("_"));
+    result = [
+        ...result,
+        ...attributes.map((seg) => {
+            if (hcl2json_2.TFExpressionSyntaxTree.isIndexTraversalPart(seg)) {
+                return `[${seg.segment}]`;
+            }
+            return seg.segment;
+        }),
+    ];
+    return result.join(".");
+}
+function convertLiteralValueExpressionToTs(_scope, node) {
+    const literalType = node.meta.type;
+    if (literalType === "number") {
+        return t.numericLiteral(Number(node.meta.value));
+    }
+    if (literalType === "bool") {
+        return t.booleanLiteral(node.meta.value === "true" ? true : false);
+    }
+    return t.stringLiteral(node.meta.value);
+}
+function convertScopeTraversalExpressionToTs(scope, node) {
+    var _a;
+    const hasReference = (0, references_1.containsReference)(node);
+    const segments = node.meta.traversal;
+    if (segments[0].segment === "each" && scope.forEachIteratorName) {
+        return dynamicVariableToAst(scope, node, scope.forEachIteratorName);
+    }
+    if (segments[0].segment === "count" && scope.countIteratorName) {
+        return dynamicVariableToAst(scope, node, scope.countIteratorName, "count");
+    }
+    if (segments[0].segment === "self") {
+        scope.importables.push({
+            constructName: "TerraformSelf",
+            provider: "cdktn",
+        });
+        return t.callExpression(t.memberExpression(t.identifier("TerraformSelf"), t.identifier("getAny")), [t.stringLiteral(traversalPartsToString(segments.slice(1)))]);
+    }
+    // setting.value, setting.value[1].id
+    const dynamicBlock = (_a = scope.scopedVariables) === null || _a === void 0 ? void 0 : _a[segments[0].segment];
+    if (dynamicBlock) {
+        if (dynamicBlock === "dynamic-block") {
+            return dynamicVariableToAst(scope, node, dynamicBlock, traversalPartsToString(segments));
+        }
+        return dynamicVariableToAst(scope, node, dynamicBlock, segments[0].segment);
+    }
+    // This may be a variable reference that we don't understand yet, so we wrap it in a template string
+    // for Terraform to handle
+    let varIdentifier = t.stringLiteral(`\${${node.meta.fullAccessor}}`);
+    if (hasReference) {
+        varIdentifier = t.identifier((0, utils_1.camelCase)(traversalToVariableName(scope, node)));
+    }
+    if (["var", "local"].includes(segments[0].segment)) {
+        const variableAccessor = segments[0].segment === "var"
+            ? t.memberExpression(varIdentifier, t.identifier("value"))
+            : varIdentifier;
+        if (segments.length > 2) {
+            scope.importables.push({
+                constructName: "Fn",
+                provider: "cdktn",
+            });
+            const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+            return t.callExpression(callee, [
+                variableAccessor,
+                t.arrayExpression(segments.slice(2).map((s) => t.stringLiteral(s.segment))),
+            ]);
+        }
+        return variableAccessor;
+    }
+    if (!hasReference || scope.withinOverrideExpression) {
+        return varIdentifier;
+    }
+    const rootSegment = segments[0].segment;
+    const attributeIndex = rootSegment === "data" ? 3 : 2;
+    const attributeSegments = segments.slice(attributeIndex);
+    const numericAccessorIndex = attributeSegments.findIndex((seg) => hcl2json_2.TFExpressionSyntaxTree.isIndexTraversalPart(seg));
+    let minAccessorIndex = numericAccessorIndex;
+    let mapAccessorIndex = -1;
+    if (numericAccessorIndex === -1) {
+        // only do this if we have to, if we already have a
+        // numeric accessor, we don't have to do this additional work
+        const resourcePath = getTfResourcePathFromNode(node);
+        let usingSubPathType = false;
+        let parts = resourcePath.split(".").filter((p) => p !== "");
+        const minParts = attributeIndex; // we need to stop before data.aws.resource_name or aws.resource_name
+        const originalParts = parts.length;
+        let hasMapAccessor = false;
+        while (parts.length >= minParts) {
+            const type = (0, terraformSchema_1.getTypeAtPath)(scope.providerSchema, parts.join("."));
+            if (type !== null) {
+                if (Array.isArray(type) && type[0] === "map" && usingSubPathType) {
+                    hasMapAccessor = true;
+                    break;
+                }
+            }
+            parts.pop();
+            usingSubPathType = true;
+        }
+        if (hasMapAccessor) {
+            mapAccessorIndex = originalParts - parts.length - 1;
+            minAccessorIndex = mapAccessorIndex;
+        }
+    }
+    const needsPropertyAccess = minAccessorIndex >= 0;
+    const refSegments = needsPropertyAccess
+        ? attributeSegments.slice(0, minAccessorIndex)
+        : attributeSegments;
+    const nonRefSegments = needsPropertyAccess
+        ? attributeSegments.slice(minAccessorIndex)
+        : [];
+    const ref = refSegments.reduce((acc, seg, index) => t.memberExpression(acc, t.identifier(index === 0 && rootSegment === "module"
+        ? (0, utils_1.camelCase)(seg.segment + "Output")
+        : (0, utils_1.camelCase)(seg.segment))), varIdentifier);
+    if (nonRefSegments.length === 0) {
+        return ref;
+    }
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+    return t.callExpression(callee, [
+        ref,
+        t.arrayExpression(nonRefSegments.map((s) => t.stringLiteral(s.segment))),
+    ]);
+}
+function convertUnaryOpExpressionToTs(scope, node) {
+    const operand = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.valueExpression));
+    let fnName = node.meta.operator;
+    if (tfUnaryOperatorsToCdktf[fnName]) {
+        fnName = tfUnaryOperatorsToCdktf[fnName];
+    }
+    else {
+        throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);
+    }
+    scope.importables.push({
+        constructName: "Op",
+        provider: "cdktn",
+    });
+    const fn = t.memberExpression(t.identifier("Op"), t.identifier(fnName));
+    return t.callExpression(fn, [operand]);
+}
+function convertBinaryOpExpressionToTs(scope, node) {
+    const left = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.lhsExpression));
+    const right = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.rhsExpression));
+    let fnName = node.meta.operator;
+    if (tfBinaryOperatorsToCdktf[fnName]) {
+        fnName = tfBinaryOperatorsToCdktf[fnName];
+    }
+    else {
+        throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);
+    }
+    scope.importables.push({
+        constructName: "Op",
+        provider: "cdktn",
+    });
+    const fn = t.memberExpression(t.identifier("Op"), t.identifier(fnName));
+    return t.callExpression(fn, [left, right]);
+}
+function convertTemplateExpressionToTs(scope, node) {
+    const parts = node.children.map((child) => ({
+        node: child,
+        expr: convertTFExpressionAstToTs(scope, child),
+    }));
+    const lastPart = parts[parts.length - 1];
+    if (t.isStringLiteral(lastPart.expr) && lastPart.expr.value === "\n") {
+        // This is a bit of a hack, but the trailing newline we add due to
+        // heredocs looks ugly and unnecessary in the generated code, so we
+        // try to remove it
+        parts.pop();
+    }
+    if (parts.length === 0) {
+        return t.stringLiteral(node.meta.value);
+    }
+    if (parts.length === 1) {
+        return parts[0].expr;
+    }
+    let isScopedTraversal = false;
+    let expressions = [];
+    for (const { node, expr } of parts) {
+        if (hcl2json_2.TFExpressionSyntaxTree.isScopeTraversalExpression(node) &&
+            !t.isStringLiteral(expr) &&
+            !t.isCallExpression(expr)) {
+            expressions.push(t.stringLiteral("${"));
+            isScopedTraversal = true;
+        }
+        else if (
+        // we should ideally be doing type coercion more
+        // carefully here, because it may not always be needed
+        t.isCallExpression(expr)) {
+            scope.importables.push({
+                constructName: "Token",
+                provider: "cdktn",
+            });
+            expressions.push(template_1.default.expression(`Token.asString(%%expr%%)`)({
+                expr,
+            }));
+            continue;
+        }
+        else {
+            if (isScopedTraversal) {
+                expressions.push(t.stringLiteral("}"));
+                isScopedTraversal = false;
+            }
+        }
+        expressions.push(expr);
+    }
+    if (isScopedTraversal) {
+        expressions.push(t.stringLiteral("}"));
+    }
+    return expressionForSerialStringConcatenation(scope, expressions);
+}
+function convertObjectExpressionToTs(scope, node) {
+    return t.objectExpression(Object.entries(node.meta.items)
+        .map(([key, value]) => {
+        const valueChild = (0, syntax_tree_1.getChildWithValue)(node, value);
+        if (!valueChild) {
+            utils_1.logger.error(`Unable to value for object key '${key}': ${value}`);
+            return null;
+        }
+        return t.objectProperty(t.identifier(key), convertTFExpressionAstToTs(scope, valueChild));
+    })
+        .filter((s) => s !== null));
+}
+function convertFunctionCallExpressionToTs(scope, node) {
+    const functionName = node.meta.name;
+    const mapping = functions_1.functionsMap[functionName];
+    if (!mapping) {
+        utils_1.logger.error(`Unknown function ${functionName} encountered. ${utils_1.leaveCommentText}`);
+        const argumentExpressions = node.children.map((child) => convertTFExpressionAstToTs(scope, child));
+        return t.callExpression(t.identifier(functionName), argumentExpressions);
+    }
+    let transformedNode = mapping.transformer
+        ? mapping.transformer(node)
+        : node;
+    const argumentExpressions = transformedNode.children.map((child) => convertTFExpressionAstToTs(scope, child));
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier(mapping.name));
+    if (mapping.parameters.length > 0 &&
+        mapping.parameters[mapping.parameters.length - 1].variadic) {
+        const lastParameterType = mapping.parameters[mapping.parameters.length - 1].type;
+        const nonVariadicArguments = argumentExpressions.slice(0, mapping.parameters.length - 1);
+        const fnCallArguments = [
+            ...nonVariadicArguments.map((argExpr, index) => (0, coerceType_1.coerceType)(scope, argExpr, (0, coerceType_1.findExpressionType)(scope, argExpr), mapping.parameters[index].type)),
+            t.arrayExpression(argumentExpressions
+                .slice(mapping.parameters.length - 1)
+                .map((argExpr) => (0, coerceType_1.coerceType)(scope, argExpr, (0, coerceType_1.findExpressionType)(scope, argExpr), lastParameterType))),
+        ];
+        return t.callExpression(callee, fnCallArguments);
+    }
+    return t.callExpression(callee, argumentExpressions.map((argExpr, index) => (0, coerceType_1.coerceType)(scope, argExpr, (0, coerceType_1.findExpressionType)(scope, argExpr), mapping.parameters[index].type)));
+}
+function convertIndexExpressionToTs(scope, node) {
+    const collectionExpressionChild = hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.collectionExpression);
+    const keyExpressionChild = hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.keyExpression);
+    const collectionExpression = convertTFExpressionAstToTs(scope, collectionExpressionChild);
+    const keyExpression = convertTFExpressionAstToTs(scope, keyExpressionChild);
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+    return t.callExpression(callee, [
+        collectionExpression,
+        t.arrayExpression([keyExpression]),
+    ]);
+}
+function convertSplatExpressionToTs(scope, node) {
+    const sourceExpressionChild = hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.sourceExpression);
+    let sourceExpression = convertTFExpressionAstToTs(scope, sourceExpressionChild);
+    // We don't convert the relative expression because everything after the splat is going to be
+    // a string
+    let relativeExpression = node.meta.eachExpression.startsWith(node.meta.anonSymbolExpression)
+        ? node.meta.eachExpression.slice(node.meta.anonSymbolExpression.length)
+        : node.meta.eachExpression;
+    const segments = relativeExpression.split(/\.|\[|\]/).filter((s) => s);
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+    return t.callExpression(callee, [
+        sourceExpression,
+        t.arrayExpression([
+            // we don't need to use the anonSymbolExpression here because
+            // it only changes between .* and [*] which we don't care about
+            t.stringLiteral("*"),
+            ...segments.map(t.stringLiteral),
+        ]),
+    ]);
+}
+function convertConditionalExpressionToTs(scope, node) {
+    const conditionChild = hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.conditionExpression);
+    let condition = convertTFExpressionAstToTs(scope, conditionChild);
+    if (t.isIdentifier(condition) && canUseFqn(conditionChild)) {
+        // We have a resource or data source here, which we would need to
+        // reference using fqn
+        condition = t.memberExpression(condition, t.identifier("fqn"));
+    }
+    const trueExpression = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.trueExpression));
+    const falseExpression = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.falseExpression));
+    scope.importables.push({
+        constructName: "conditional",
+        provider: "cdktn",
+    });
+    return t.callExpression(t.identifier("conditional"), [
+        condition,
+        trueExpression,
+        falseExpression,
+    ]);
+}
+function convertTupleExpressionToTs(scope, node) {
+    const expressions = node.children.map((child) => convertTFExpressionAstToTs(scope, child));
+    return t.arrayExpression(expressions);
+}
+function convertRelativeTraversalExpressionToTs(scope, node) {
+    const segments = node.meta.traversal;
+    // The left hand side / source of a relative traversal is not a proper
+    // object / resource / data thing that is being referenced
+    const source = convertTFExpressionAstToTs(scope, hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.sourceExpression));
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+    return t.callExpression(callee, [
+        source,
+        t.arrayExpression(segments.map((s) => t.stringLiteral(s.segment))),
+    ]);
+}
+function convertForExpressionToTs(scope, node) {
+    const collectionChild = hcl2json_2.TFExpressionSyntaxTree.getChildWithValue(node, node.meta.collectionExpression);
+    let collectionExpression = convertTFExpressionAstToTs(scope, collectionChild);
+    if (t.isIdentifier(collectionExpression) && canUseFqn(collectionChild)) {
+        // We have a resource or data source here, which we would need to
+        // reference using fqn
+        collectionExpression = t.memberExpression(collectionExpression, t.identifier("fqn"));
+    }
+    const collectionRequiresWrapping = !t.isStringLiteral(collectionExpression);
+    const expressions = [];
+    const conditionBody = node.meta.keyVar
+        ? `${node.meta.keyVar}, ${node.meta.valVar}`
+        : node.meta.valVar;
+    const openBrace = node.meta.openRangeValue;
+    const closeBrace = node.meta.closeRangeValue;
+    const grouped = node.meta.groupedValue ? "..." : "";
+    const valueExpression = `${node.meta.valueExpression}${grouped}`;
+    const prefix = `\${${openBrace} for ${conditionBody} in `;
+    const keyValue = node.meta.keyExpression
+        ? ` : ${node.meta.keyExpression} => ${valueExpression}`
+        : ` : ${valueExpression}`;
+    const conditional = node.meta.conditionalExpression;
+    const suffix = `${keyValue}${conditional ? ` if ${conditional}` : ""}${closeBrace}}`;
+    expressions.push(t.stringLiteral(prefix));
+    if (collectionRequiresWrapping) {
+        expressions.push(t.stringLiteral("${"));
+    }
+    expressions.push(collectionExpression);
+    if (collectionRequiresWrapping) {
+        expressions.push(t.stringLiteral("}"));
+    }
+    expressions.push(t.stringLiteral(suffix));
+    return expressionForSerialStringConcatenation(scope, expressions);
+}
+function convertTFExpressionAstToTs(scope, node) {
+    if (hcl2json_2.TFExpressionSyntaxTree.isLiteralValueExpression(node)) {
+        return convertLiteralValueExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isScopeTraversalExpression(node)) {
+        return convertScopeTraversalExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isUnaryOpExpression(node)) {
+        return convertUnaryOpExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isBinaryOpExpression(node)) {
+        return convertBinaryOpExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isTemplateExpression(node) || hcl2json_2.TFExpressionSyntaxTree.isTemplateWrapExpression(node)) {
+        return convertTemplateExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isObjectExpression(node)) {
+        return convertObjectExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isFunctionCallExpression(node)) {
+        return convertFunctionCallExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isIndexExpression(node)) {
+        return convertIndexExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isSplatExpression(node)) {
+        return convertSplatExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isConditionalExpression(node)) {
+        return convertConditionalExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isTupleExpression(node)) {
+        return convertTupleExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isRelativeTraversalExpression(node)) {
+        return convertRelativeTraversalExpressionToTs(scope, node);
+    }
+    if (hcl2json_2.TFExpressionSyntaxTree.isForExpression(node)) {
+        return convertForExpressionToTs(scope, node);
+    }
+    return t.stringLiteral("");
+}
+async function expressionAst(input) {
+    const { wrap, wrapOffset } = (0, hcl2json_2.wrapTerraformExpression)(input);
+    const ast = await (0, hcl2json_1.getExpressionAst)("main.tf", wrap);
+    if (!ast) {
+        throw new Error(`Unable to parse terraform expression: ${input}`);
+    }
+    if (wrapOffset != 0 && hcl2json_2.TFExpressionSyntaxTree.isTemplateWrapExpression(ast)) {
+        return ast.children[0];
+    }
+    return ast;
+}
+exports.expressionAst = expressionAst;
+async function convertTerraformExpressionToTs(scope, input, targetType) {
+    utils_1.logger.debug(`convertTerraformExpressionToTs(${input})`);
+    const tsExpression = convertTFExpressionAstToTs(scope, await expressionAst(input));
+    return (0, coerceType_1.coerceType)(scope, tsExpression, (0, coerceType_1.findExpressionType)(scope, tsExpression), targetType());
+}
+exports.convertTerraformExpressionToTs = convertTerraformExpressionToTs;
+async function extractIteratorVariablesFromExpression(input) {
+    const possibleVariableSpots = await (0, hcl2json_1.getReferencesInExpression)("main.tf", input);
+    return possibleVariableSpots
+        .filter((spot) => spot.value.startsWith("each."))
+        .map((spot) => ({
+        start: spot.startPosition,
+        end: spot.endPosition,
+        value: spot.value,
+    }));
+}
+exports.extractIteratorVariablesFromExpression = extractIteratorVariablesFromExpression;
+function dynamicVariableToAst(scope, node, iteratorName, block = "each") {
+    if (iteratorName === "dynamic-block") {
+        return expressionForSerialStringConcatenation(scope, [
+            t.stringLiteral("${"),
+            t.stringLiteral(block),
+            t.stringLiteral("}"),
+        ]);
+    }
+    if (node.meta.value === `${block}.key`) {
+        return t.memberExpression(t.identifier(iteratorName), t.identifier("key"));
+    }
+    if (node.meta.value === `${block}.value`) {
+        return t.memberExpression(t.identifier(iteratorName), t.identifier("value"));
+    }
+    if (block === "count" && node.meta.value === `${block}.index`) {
+        return t.memberExpression(t.identifier(iteratorName), t.identifier("index"));
+    }
+    const segments = node.meta.traversal;
+    if (segments.length > 2 &&
+        segments[0].segment === block &&
+        segments[1].segment === "value") {
+        const segmentsAfterEachValue = segments.slice(2);
+        scope.importables.push({
+            constructName: "Fn",
+            provider: "cdktn",
+        });
+        const callee = t.memberExpression(t.identifier("Fn"), t.identifier("lookupNested"));
+        return t.callExpression(callee, [
+            t.memberExpression(t.identifier(iteratorName), t.identifier("value")),
+            t.arrayExpression(segmentsAfterEachValue.map((part) => {
+                if (part.type === "nameTraversal") {
+                    return t.stringLiteral(part.segment);
+                }
+                else {
+                    return t.stringLiteral(`[${part.segment}]`);
+                }
+            })),
+        ]);
+    }
+    throw new Error(`Can not create AST for iterator variable of '${node.meta.value}'`);
+}
+exports.dynamicVariableToAst = dynamicVariableToAst;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expressions.js","sourceRoot":"","sources":["expressions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as t from \"@babel/types\";\nimport template from \"@babel/template\";\nimport { camelCase, leaveCommentText, logger } from \"./utils\";\nimport {\n  IteratorVariableReference,\n  ProgramScope,\n  ResourceScope,\n} from \"./types\";\nimport { getReferencesInExpression, getExpressionAst } from \"@cdktn/hcl2json\";\nimport {\n  TFExpressionSyntaxTree as tex,\n  wrapTerraformExpression,\n} from \"@cdktn/hcl2json\";\nimport { functionsMap } from \"./function-bindings/functions\";\nimport { coerceType, findExpressionType } from \"./coerceType\";\nimport { AttributeType } from \"@cdktn/commons\";\nimport { getTypeAtPath } from \"./terraformSchema\";\nimport { containsReference } from \"./references\";\nimport { variableName } from \"./variables\";\nimport { getChildWithValue } from \"@cdktn/hcl2json/lib/syntax-tree\";\n\nconst tfBinaryOperatorsToCdktf = {\n  logicalOr: \"or\",\n  logicalAnd: \"and\",\n  greaterThan: \"gt\",\n  greaterThanOrEqual: \"gte\",\n  lessThan: \"lt\",\n  lessThanOrEqual: \"lte\",\n  equal: \"eq\",\n  notEqual: \"neq\",\n  add: \"add\",\n  subtract: \"sub\",\n  multiply: \"mul\",\n  divide: \"div\",\n  modulo: \"mod\",\n};\n\nconst tfUnaryOperatorsToCdktf = {\n  logicalNot: \"not\",\n  negate: \"negate\",\n};\n\ntype supportedBinaryOperators = keyof typeof tfBinaryOperatorsToCdktf;\ntype supportedUnaryOperators = keyof typeof tfUnaryOperatorsToCdktf;\n\nfunction traversalPartsToString(\n  traversals: tex.TerraformTraversalPart[],\n  asSuffix = false,\n) {\n  let seed = \"\";\n  if (asSuffix && tex.isNameTraversalPart(traversals[0])) {\n    seed = \".\";\n  }\n  return traversals.reduce((acc, part) => {\n    if (part.type === \"nameTraversal\") {\n      if (acc === seed) {\n        return `${acc}${part.segment}`;\n      }\n      return `${acc}.${part.segment}`;\n    }\n    return `${acc}[${part.segment}]`;\n  }, seed);\n}\n\nfunction canUseFqn(expression: tex.ExpressionType) {\n  if (!tex.isScopeTraversalExpression(expression)) {\n    return false;\n  }\n\n  const rootSegment = expression.meta.traversal[0].segment;\n\n  return ![\"var\", \"local\"].includes(rootSegment);\n}\n\nfunction traversalToVariableName(\n  scope: ProgramScope,\n  node: tex.ExpressionType,\n) {\n  if (!tex.isScopeTraversalExpression(node)) {\n    logger.error(\n      `Unexpected expression type ${node.type} with value ${node.meta.value} passed to convert to a variable. \n        ${leaveCommentText}`,\n    );\n    return \"\";\n  }\n\n  const segments = node.meta.traversal;\n  if (segments.length === 1) {\n    return node.meta.fullAccessor;\n  }\n  const rootSegment = segments[0].segment;\n  const resource =\n    rootSegment === \"data\"\n      ? `${segments[0].segment}.${segments[1].segment}`\n      : rootSegment;\n  const name =\n    rootSegment === \"data\" ? segments[2].segment : segments[1].segment;\n\n  return variableName(scope, resource, name);\n}\n\nfunction expressionForSerialStringConcatenation(\n  scope: ResourceScope,\n  nodes: t.Expression[],\n) {\n  const reducedNodes = nodes.reduce((acc, node) => {\n    const prev = acc[acc.length - 1];\n    if (!prev) return [node];\n\n    if (t.isStringLiteral(prev) && t.isStringLiteral(node)) {\n      acc.pop();\n      acc.push(t.stringLiteral(prev.value + node.value));\n      return acc;\n    }\n\n    acc.push(node);\n    return acc;\n  }, [] as t.Expression[]);\n\n  return reducedNodes.reduce(\n    (acc: t.Expression | undefined, node: t.Expression) => {\n      if (!acc) {\n        return node;\n      }\n\n      // wrap access to dynamic blocks in Token.asString() as they return a Lazy\n      // for .key and .value which can't be concatenated in languages like Python\n      // because JSII currently has no support for the toString() method in\n      // languages other than TypeScript: https://github.com/aws/jsii/issues/380\n      // example: dynamic_iterator0.key / dynamic_iterator0.value\n      if (\n        t.isMemberExpression(node) &&\n        t.isIdentifier(node.object) &&\n        Object.values(scope.scopedVariables || {}).includes(node.object.name) &&\n        t.isIdentifier(node.property) &&\n        [\"key\", \"value\"].includes(node.property.name)\n      ) {\n        node = coerceType(scope, node, \"dynamic\", \"string\");\n      }\n\n      return t.binaryExpression(\"+\", acc as t.Expression, node);\n    },\n  );\n}\n\nfunction getTfResourcePathFromNode(node: tex.ScopeTraversalExpression) {\n  const segments = node.meta.traversal;\n  let resource = segments[0].segment;\n  let result = [];\n  let attributes = [];\n\n  if (segments[0].segment === \"data\") {\n    result.push(segments[0].segment);\n    resource = segments[1].segment;\n    attributes = segments.slice(3); // we want to skip the variable name\n  } else {\n    attributes = segments.slice(2); // we want to skip the variable name\n  }\n\n  const [provider, ...resourceNameFragments] = resource.split(\"_\");\n\n  // Hack: This happens in the case of `external` provider\n  // where the data source does not have a provider name prefix\n  if (resourceNameFragments.length === 0) {\n    resourceNameFragments.push(provider);\n  }\n\n  result.push(provider);\n  result.push(resourceNameFragments.join(\"_\"));\n  result = [\n    ...result,\n    ...attributes.map((seg) => {\n      if (tex.isIndexTraversalPart(seg)) {\n        return `[${seg.segment}]`;\n      }\n      return seg.segment;\n    }),\n  ];\n\n  return result.join(\".\");\n}\n\nfunction convertLiteralValueExpressionToTs(\n  _scope: ResourceScope,\n  node: tex.LiteralValueExpression,\n) {\n  const literalType = node.meta.type;\n  if (literalType === \"number\") {\n    return t.numericLiteral(Number(node.meta.value));\n  }\n  if (literalType === \"bool\") {\n    return t.booleanLiteral(node.meta.value === \"true\" ? true : false);\n  }\n\n  return t.stringLiteral(node.meta.value);\n}\n\nfunction convertScopeTraversalExpressionToTs(\n  scope: ResourceScope,\n  node: tex.ScopeTraversalExpression,\n) {\n  const hasReference = containsReference(node);\n\n  const segments = node.meta.traversal;\n\n  if (segments[0].segment === \"each\" && scope.forEachIteratorName) {\n    return dynamicVariableToAst(scope, node, scope.forEachIteratorName);\n  }\n\n  if (segments[0].segment === \"count\" && scope.countIteratorName) {\n    return dynamicVariableToAst(scope, node, scope.countIteratorName, \"count\");\n  }\n\n  if (segments[0].segment === \"self\") {\n    scope.importables.push({\n      constructName: \"TerraformSelf\",\n      provider: \"cdktn\",\n    });\n\n    return t.callExpression(\n      t.memberExpression(t.identifier(\"TerraformSelf\"), t.identifier(\"getAny\")),\n\n      [t.stringLiteral(traversalPartsToString(segments.slice(1)))],\n    );\n  }\n\n  // setting.value, setting.value[1].id\n  const dynamicBlock = scope.scopedVariables?.[segments[0].segment];\n  if (dynamicBlock) {\n    if (dynamicBlock === \"dynamic-block\") {\n      return dynamicVariableToAst(\n        scope,\n        node,\n        dynamicBlock,\n        traversalPartsToString(segments),\n      );\n    }\n    return dynamicVariableToAst(scope, node, dynamicBlock, segments[0].segment);\n  }\n\n  // This may be a variable reference that we don't understand yet, so we wrap it in a template string\n  // for Terraform to handle\n  let varIdentifier: t.Expression = t.stringLiteral(\n    `\\${${node.meta.fullAccessor}}`,\n  );\n\n  if (hasReference) {\n    varIdentifier = t.identifier(\n      camelCase(traversalToVariableName(scope, node)),\n    );\n  }\n\n  if ([\"var\", \"local\"].includes(segments[0].segment)) {\n    const variableAccessor =\n      segments[0].segment === \"var\"\n        ? t.memberExpression(varIdentifier, t.identifier(\"value\"))\n        : varIdentifier;\n\n    if (segments.length > 2) {\n      scope.importables.push({\n        constructName: \"Fn\",\n        provider: \"cdktn\",\n      });\n      const callee = t.memberExpression(\n        t.identifier(\"Fn\"),\n        t.identifier(\"lookupNested\"),\n      );\n      return t.callExpression(callee, [\n        variableAccessor,\n        t.arrayExpression(\n          segments.slice(2).map((s) => t.stringLiteral(s.segment)),\n        ),\n      ]);\n    }\n\n    return variableAccessor;\n  }\n\n  if (!hasReference || scope.withinOverrideExpression) {\n    return varIdentifier;\n  }\n\n  const rootSegment = segments[0].segment;\n  const attributeIndex = rootSegment === \"data\" ? 3 : 2;\n  const attributeSegments = segments.slice(attributeIndex);\n  const numericAccessorIndex = attributeSegments.findIndex((seg) =>\n    tex.isIndexTraversalPart(seg),\n  );\n  let minAccessorIndex = numericAccessorIndex;\n  let mapAccessorIndex = -1;\n  if (numericAccessorIndex === -1) {\n    // only do this if we have to, if we already have a\n    // numeric accessor, we don't have to do this additional work\n    const resourcePath = getTfResourcePathFromNode(node);\n    let usingSubPathType = false;\n    let parts = resourcePath.split(\".\").filter((p) => p !== \"\");\n    const minParts = attributeIndex; // we need to stop before data.aws.resource_name or aws.resource_name\n    const originalParts = parts.length;\n    let hasMapAccessor = false;\n    while (parts.length >= minParts) {\n      const type = getTypeAtPath(scope.providerSchema, parts.join(\".\"));\n      if (type !== null) {\n        if (Array.isArray(type) && type[0] === \"map\" && usingSubPathType) {\n          hasMapAccessor = true;\n          break;\n        }\n      }\n      parts.pop();\n      usingSubPathType = true;\n    }\n\n    if (hasMapAccessor) {\n      mapAccessorIndex = originalParts - parts.length - 1;\n      minAccessorIndex = mapAccessorIndex;\n    }\n  }\n\n  const needsPropertyAccess = minAccessorIndex >= 0;\n\n  const refSegments = needsPropertyAccess\n    ? attributeSegments.slice(0, minAccessorIndex)\n    : attributeSegments;\n  const nonRefSegments = needsPropertyAccess\n    ? attributeSegments.slice(minAccessorIndex)\n    : [];\n\n  const ref = refSegments.reduce(\n    (acc: t.Expression, seg, index) =>\n      t.memberExpression(\n        acc,\n        t.identifier(\n          index === 0 && rootSegment === \"module\"\n            ? camelCase(seg.segment + \"Output\")\n            : camelCase(seg.segment),\n        ),\n      ),\n    varIdentifier,\n  );\n\n  if (nonRefSegments.length === 0) {\n    return ref;\n  }\n\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(\"lookupNested\"),\n  );\n  return t.callExpression(callee, [\n    ref,\n    t.arrayExpression(nonRefSegments.map((s) => t.stringLiteral(s.segment))),\n  ]);\n}\n\nfunction convertUnaryOpExpressionToTs(\n  scope: ResourceScope,\n  node: tex.UnaryOpExpression,\n) {\n  const operand = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.valueExpression)!,\n  );\n\n  let fnName = node.meta.operator;\n  if (tfUnaryOperatorsToCdktf[fnName as supportedUnaryOperators]) {\n    fnName = tfUnaryOperatorsToCdktf[fnName as supportedUnaryOperators];\n  } else {\n    throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);\n  }\n\n  scope.importables.push({\n    constructName: \"Op\",\n    provider: \"cdktn\",\n  });\n\n  const fn = t.memberExpression(t.identifier(\"Op\"), t.identifier(fnName));\n\n  return t.callExpression(fn, [operand]);\n}\n\nfunction convertBinaryOpExpressionToTs(\n  scope: ResourceScope,\n  node: tex.BinaryOpExpression,\n) {\n  const left = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.lhsExpression)!,\n  );\n  const right = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.rhsExpression)!,\n  );\n\n  let fnName = node.meta.operator;\n  if (tfBinaryOperatorsToCdktf[fnName as supportedBinaryOperators]) {\n    fnName = tfBinaryOperatorsToCdktf[fnName as supportedBinaryOperators];\n  } else {\n    throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);\n  }\n\n  scope.importables.push({\n    constructName: \"Op\",\n    provider: \"cdktn\",\n  });\n\n  const fn = t.memberExpression(t.identifier(\"Op\"), t.identifier(fnName));\n  return t.callExpression(fn, [left, right]);\n}\n\nfunction convertTemplateExpressionToTs(\n  scope: ResourceScope,\n  node: tex.TemplateExpression | tex.TemplateWrapExpression,\n) {\n  const parts = node.children.map((child) => ({\n    node: child,\n    expr: convertTFExpressionAstToTs(scope, child),\n  }));\n\n  const lastPart = parts[parts.length - 1];\n  if (t.isStringLiteral(lastPart.expr) && lastPart.expr.value === \"\\n\") {\n    // This is a bit of a hack, but the trailing newline we add due to\n    // heredocs looks ugly and unnecessary in the generated code, so we\n    // try to remove it\n    parts.pop();\n  }\n\n  if (parts.length === 0) {\n    return t.stringLiteral(node.meta.value);\n  }\n\n  if (parts.length === 1) {\n    return parts[0].expr;\n  }\n\n  let isScopedTraversal = false;\n  let expressions: t.Expression[] = [];\n  for (const { node, expr } of parts) {\n    if (\n      tex.isScopeTraversalExpression(node) &&\n      !t.isStringLiteral(expr) &&\n      !t.isCallExpression(expr)\n    ) {\n      expressions.push(t.stringLiteral(\"${\"));\n      isScopedTraversal = true;\n    } else if (\n      // we should ideally be doing type coercion more\n      // carefully here, because it may not always be needed\n      t.isCallExpression(expr)\n    ) {\n      scope.importables.push({\n        constructName: \"Token\",\n        provider: \"cdktn\",\n      });\n\n      expressions.push(\n        template.expression(`Token.asString(%%expr%%)`)({\n          expr,\n        }) as t.Expression,\n      );\n      continue;\n    } else {\n      if (isScopedTraversal) {\n        expressions.push(t.stringLiteral(\"}\"));\n        isScopedTraversal = false;\n      }\n    }\n    expressions.push(expr);\n  }\n\n  if (isScopedTraversal) {\n    expressions.push(t.stringLiteral(\"}\"));\n  }\n\n  return expressionForSerialStringConcatenation(scope, expressions);\n}\n\nfunction convertObjectExpressionToTs(\n  scope: ResourceScope,\n  node: tex.ObjectExpression,\n) {\n  return t.objectExpression(\n    Object.entries(node.meta.items)\n      .map(([key, value]) => {\n        const valueChild = getChildWithValue(node, value);\n        if (!valueChild) {\n          logger.error(`Unable to value for object key '${key}': ${value}`);\n          return null;\n        }\n\n        return t.objectProperty(\n          t.identifier(key),\n          convertTFExpressionAstToTs(scope, valueChild),\n        );\n      })\n      .filter((s) => s !== null) as t.ObjectProperty[],\n  );\n}\n\nfunction convertFunctionCallExpressionToTs(\n  scope: ResourceScope,\n  node: tex.FunctionCallExpression,\n) {\n  const functionName = node.meta.name;\n  const mapping = functionsMap[functionName];\n\n  if (!mapping) {\n    logger.error(\n      `Unknown function ${functionName} encountered. ${leaveCommentText}`,\n    );\n    const argumentExpressions = node.children.map((child) =>\n      convertTFExpressionAstToTs(scope, child),\n    );\n\n    return t.callExpression(t.identifier(functionName), argumentExpressions);\n  }\n\n  let transformedNode: tex.FunctionCallExpression = mapping.transformer\n    ? mapping.transformer(node)\n    : node;\n\n  const argumentExpressions = transformedNode.children.map((child) =>\n    convertTFExpressionAstToTs(scope, child),\n  );\n\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(mapping.name),\n  );\n\n  if (\n    mapping.parameters.length > 0 &&\n    mapping.parameters[mapping.parameters.length - 1].variadic\n  ) {\n    const lastParameterType =\n      mapping.parameters[mapping.parameters.length - 1].type;\n    const nonVariadicArguments = argumentExpressions.slice(\n      0,\n      mapping.parameters.length - 1,\n    );\n\n    const fnCallArguments = [\n      ...nonVariadicArguments.map((argExpr, index) =>\n        coerceType(\n          scope,\n          argExpr,\n          findExpressionType(scope, argExpr),\n          mapping.parameters[index].type,\n        ),\n      ),\n\n      t.arrayExpression(\n        argumentExpressions\n          .slice(mapping.parameters.length - 1)\n          .map((argExpr) =>\n            coerceType(\n              scope,\n              argExpr,\n              findExpressionType(scope, argExpr),\n              lastParameterType,\n            ),\n          ),\n      ),\n    ];\n\n    return t.callExpression(callee, fnCallArguments);\n  }\n\n  return t.callExpression(\n    callee,\n    argumentExpressions.map((argExpr, index) =>\n      coerceType(\n        scope,\n        argExpr,\n        findExpressionType(scope, argExpr),\n        mapping.parameters[index].type,\n      ),\n    ),\n  );\n}\n\nfunction convertIndexExpressionToTs(\n  scope: ResourceScope,\n  node: tex.IndexExpression,\n) {\n  const collectionExpressionChild = tex.getChildWithValue(\n    node,\n    node.meta.collectionExpression,\n  );\n  const keyExpressionChild = tex.getChildWithValue(\n    node,\n    node.meta.keyExpression,\n  );\n\n  const collectionExpression = convertTFExpressionAstToTs(\n    scope,\n    collectionExpressionChild!,\n  );\n  const keyExpression = convertTFExpressionAstToTs(scope, keyExpressionChild!);\n\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(\"lookupNested\"),\n  );\n  return t.callExpression(callee, [\n    collectionExpression,\n    t.arrayExpression([keyExpression]),\n  ]);\n}\n\nfunction convertSplatExpressionToTs(\n  scope: ResourceScope,\n  node: tex.SplatExpression,\n) {\n  const sourceExpressionChild = tex.getChildWithValue(\n    node,\n    node.meta.sourceExpression,\n  )!;\n  let sourceExpression = convertTFExpressionAstToTs(\n    scope,\n    sourceExpressionChild,\n  );\n\n  // We don't convert the relative expression because everything after the splat is going to be\n  // a string\n  let relativeExpression = node.meta.eachExpression.startsWith(\n    node.meta.anonSymbolExpression,\n  )\n    ? node.meta.eachExpression.slice(node.meta.anonSymbolExpression.length)\n    : node.meta.eachExpression;\n\n  const segments = relativeExpression.split(/\\.|\\[|\\]/).filter((s) => s);\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(\"lookupNested\"),\n  );\n\n  return t.callExpression(callee, [\n    sourceExpression,\n    t.arrayExpression([\n      // we don't need to use the anonSymbolExpression here because\n      // it only changes between .* and [*] which we don't care about\n      t.stringLiteral(\"*\"),\n      ...segments.map(t.stringLiteral),\n    ]),\n  ]);\n}\n\nfunction convertConditionalExpressionToTs(\n  scope: ResourceScope,\n  node: tex.ConditionalExpression,\n) {\n  const conditionChild = tex.getChildWithValue(\n    node,\n    node.meta.conditionExpression,\n  )!;\n  let condition = convertTFExpressionAstToTs(scope, conditionChild);\n  if (t.isIdentifier(condition) && canUseFqn(conditionChild)) {\n    // We have a resource or data source here, which we would need to\n    // reference using fqn\n    condition = t.memberExpression(condition, t.identifier(\"fqn\"));\n  }\n\n  const trueExpression = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.trueExpression)!,\n  );\n\n  const falseExpression = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.falseExpression)!,\n  );\n\n  scope.importables.push({\n    constructName: \"conditional\",\n    provider: \"cdktn\",\n  });\n\n  return t.callExpression(t.identifier(\"conditional\"), [\n    condition,\n    trueExpression,\n    falseExpression,\n  ]);\n}\n\nfunction convertTupleExpressionToTs(\n  scope: ResourceScope,\n  node: tex.TupleExpression,\n) {\n  const expressions = node.children.map((child) =>\n    convertTFExpressionAstToTs(scope, child),\n  );\n\n  return t.arrayExpression(expressions);\n}\n\nfunction convertRelativeTraversalExpressionToTs(\n  scope: ResourceScope,\n  node: tex.RelativeTraversalExpression,\n) {\n  const segments = node.meta.traversal;\n\n  // The left hand side / source of a relative traversal is not a proper\n  // object / resource / data thing that is being referenced\n  const source = convertTFExpressionAstToTs(\n    scope,\n    tex.getChildWithValue(node, node.meta.sourceExpression)!,\n  );\n\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(\"lookupNested\"),\n  );\n\n  return t.callExpression(callee, [\n    source,\n    t.arrayExpression(segments.map((s) => t.stringLiteral(s.segment))),\n  ]);\n}\n\nfunction convertForExpressionToTs(\n  scope: ResourceScope,\n  node: tex.ForExpression,\n) {\n  const collectionChild = tex.getChildWithValue(\n    node,\n    node.meta.collectionExpression,\n  )!;\n\n  let collectionExpression = convertTFExpressionAstToTs(scope, collectionChild);\n\n  if (t.isIdentifier(collectionExpression) && canUseFqn(collectionChild)) {\n    // We have a resource or data source here, which we would need to\n    // reference using fqn\n    collectionExpression = t.memberExpression(\n      collectionExpression,\n      t.identifier(\"fqn\"),\n    );\n  }\n\n  const collectionRequiresWrapping = !t.isStringLiteral(collectionExpression);\n  const expressions = [];\n  const conditionBody = node.meta.keyVar\n    ? `${node.meta.keyVar}, ${node.meta.valVar}`\n    : node.meta.valVar;\n\n  const openBrace = node.meta.openRangeValue;\n  const closeBrace = node.meta.closeRangeValue;\n  const grouped = node.meta.groupedValue ? \"...\" : \"\";\n  const valueExpression = `${node.meta.valueExpression}${grouped}`;\n\n  const prefix = `\\${${openBrace} for ${conditionBody} in `;\n  const keyValue = node.meta.keyExpression\n    ? ` : ${node.meta.keyExpression} => ${valueExpression}`\n    : ` : ${valueExpression}`;\n  const conditional = node.meta.conditionalExpression;\n  const suffix = `${keyValue}${\n    conditional ? ` if ${conditional}` : \"\"\n  }${closeBrace}}`;\n\n  expressions.push(t.stringLiteral(prefix));\n  if (collectionRequiresWrapping) {\n    expressions.push(t.stringLiteral(\"${\"));\n  }\n  expressions.push(collectionExpression);\n  if (collectionRequiresWrapping) {\n    expressions.push(t.stringLiteral(\"}\"));\n  }\n  expressions.push(t.stringLiteral(suffix));\n\n  return expressionForSerialStringConcatenation(scope, expressions);\n}\n\nfunction convertTFExpressionAstToTs(\n  scope: ResourceScope,\n  node: tex.ExpressionType,\n): t.Expression {\n  if (tex.isLiteralValueExpression(node)) {\n    return convertLiteralValueExpressionToTs(scope, node);\n  }\n\n  if (tex.isScopeTraversalExpression(node)) {\n    return convertScopeTraversalExpressionToTs(scope, node);\n  }\n\n  if (tex.isUnaryOpExpression(node)) {\n    return convertUnaryOpExpressionToTs(scope, node);\n  }\n\n  if (tex.isBinaryOpExpression(node)) {\n    return convertBinaryOpExpressionToTs(scope, node);\n  }\n\n  if (tex.isTemplateExpression(node) || tex.isTemplateWrapExpression(node)) {\n    return convertTemplateExpressionToTs(scope, node);\n  }\n\n  if (tex.isObjectExpression(node)) {\n    return convertObjectExpressionToTs(scope, node);\n  }\n\n  if (tex.isFunctionCallExpression(node)) {\n    return convertFunctionCallExpressionToTs(scope, node);\n  }\n\n  if (tex.isIndexExpression(node)) {\n    return convertIndexExpressionToTs(scope, node);\n  }\n\n  if (tex.isSplatExpression(node)) {\n    return convertSplatExpressionToTs(scope, node);\n  }\n\n  if (tex.isConditionalExpression(node)) {\n    return convertConditionalExpressionToTs(scope, node);\n  }\n\n  if (tex.isTupleExpression(node)) {\n    return convertTupleExpressionToTs(scope, node);\n  }\n\n  if (tex.isRelativeTraversalExpression(node)) {\n    return convertRelativeTraversalExpressionToTs(scope, node);\n  }\n\n  if (tex.isForExpression(node)) {\n    return convertForExpressionToTs(scope, node);\n  }\n\n  return t.stringLiteral(\"\");\n}\n\nexport async function expressionAst(\n  input: string,\n): Promise<tex.ExpressionType> {\n  const { wrap, wrapOffset } = wrapTerraformExpression(input);\n  const ast = await getExpressionAst(\"main.tf\", wrap);\n\n  if (!ast) {\n    throw new Error(`Unable to parse terraform expression: ${input}`);\n  }\n\n  if (wrapOffset != 0 && tex.isTemplateWrapExpression(ast)) {\n    return ast.children[0];\n  }\n\n  return ast;\n}\n\nexport async function convertTerraformExpressionToTs(\n  scope: ResourceScope,\n  input: string,\n  targetType: () => AttributeType,\n): Promise<t.Expression> {\n  logger.debug(`convertTerraformExpressionToTs(${input})`);\n  const tsExpression = convertTFExpressionAstToTs(\n    scope,\n    await expressionAst(input),\n  );\n\n  return coerceType(\n    scope,\n    tsExpression,\n    findExpressionType(scope, tsExpression),\n    targetType(),\n  );\n}\n\nexport async function extractIteratorVariablesFromExpression(\n  input: string,\n): Promise<IteratorVariableReference[]> {\n  const possibleVariableSpots = await getReferencesInExpression(\n    \"main.tf\",\n    input,\n  );\n\n  return possibleVariableSpots\n    .filter((spot) => spot.value.startsWith(\"each.\"))\n    .map((spot) => ({\n      start: spot.startPosition,\n      end: spot.endPosition,\n      value: spot.value,\n    }));\n}\n\nexport function dynamicVariableToAst(\n  scope: ProgramScope,\n  node: tex.ScopeTraversalExpression,\n  iteratorName: string,\n  block: string = \"each\",\n): t.Expression {\n  if (iteratorName === \"dynamic-block\") {\n    return expressionForSerialStringConcatenation(scope, [\n      t.stringLiteral(\"${\"),\n      t.stringLiteral(block),\n      t.stringLiteral(\"}\"),\n    ]);\n  }\n  if (node.meta.value === `${block}.key`) {\n    return t.memberExpression(t.identifier(iteratorName), t.identifier(\"key\"));\n  }\n  if (node.meta.value === `${block}.value`) {\n    return t.memberExpression(\n      t.identifier(iteratorName),\n      t.identifier(\"value\"),\n    );\n  }\n\n  if (block === \"count\" && node.meta.value === `${block}.index`) {\n    return t.memberExpression(\n      t.identifier(iteratorName),\n      t.identifier(\"index\"),\n    );\n  }\n\n  const segments = node.meta.traversal;\n\n  if (\n    segments.length > 2 &&\n    segments[0].segment === block &&\n    segments[1].segment === \"value\"\n  ) {\n    const segmentsAfterEachValue = segments.slice(2);\n    scope.importables.push({\n      constructName: \"Fn\",\n      provider: \"cdktn\",\n    });\n    const callee = t.memberExpression(\n      t.identifier(\"Fn\"),\n      t.identifier(\"lookupNested\"),\n    );\n    return t.callExpression(callee, [\n      t.memberExpression(t.identifier(iteratorName), t.identifier(\"value\")),\n      t.arrayExpression(\n        segmentsAfterEachValue.map((part) => {\n          if (part.type === \"nameTraversal\") {\n            return t.stringLiteral(part.segment);\n          } else {\n            return t.stringLiteral(`[${part.segment}]`);\n          }\n        }),\n      ),\n    ]);\n  }\n\n  throw new Error(\n    `Can not create AST for iterator variable of '${node.meta.value}'`,\n  );\n}\n"]}