@tsonic/frontend 0.0.1 → 0.0.4

package/dist/ir/converters/expressions/helpers.js

@@ -0,0 +1,217 @@
+/**
+ * Helper functions for expression conversion
+ */
+import * as ts from "typescript";
+import { convertType, convertTsTypeToIr } from "../../type-converter.js";
+/**
+ * Helper to get inferred type from TypeScript node
+ * Prefers contextual type (from assignment target, return position, etc.)
+ * over literal type to handle cases like empty arrays `[]` correctly.
+ */
+export const getInferredType = (node, checker) => {
+    try {
+        // Try contextual type first (from assignment target, parameter, return, etc.)
+        // This is essential for empty arrays: [] has literal type never[] but contextual
+        // type Player[] when assigned to a Player[] variable
+        const expr = ts.isExpression(node) ? node : undefined;
+        const contextualType = expr ? checker.getContextualType(expr) : undefined;
+        const tsType = contextualType ?? checker.getTypeAtLocation(node);
+        // First try typeToTypeNode for simple types
+        const typeNode = checker.typeToTypeNode(tsType, node, ts.NodeBuilderFlags.None);
+        // If typeNode conversion works, use convertType
+        if (typeNode) {
+            return convertType(typeNode, checker);
+        }
+        // Fallback: use convertTsTypeToIr directly for complex types
+        // This handles intersection types like List_1$instance<T> that can't be converted to TypeNodes
+        return convertTsTypeToIr(tsType, checker);
+    }
+    catch {
+        // If type extraction fails, return undefined
+        return undefined;
+    }
+};
+/**
+ * Extract type arguments from a call or new expression
+ * This captures both explicit type arguments and inferred ones
+ */
+export const extractTypeArguments = (node, checker) => {
+    try {
+        // First check for explicit type arguments
+        if (node.typeArguments && node.typeArguments.length > 0) {
+            return node.typeArguments.map((typeArg) => convertType(typeArg, checker));
+        }
+        // Try to get inferred type arguments from resolved signature
+        const signature = checker.getResolvedSignature(node);
+        if (!signature) {
+            return undefined;
+        }
+        const typeParameters = signature.typeParameters;
+        if (!typeParameters || typeParameters.length === 0) {
+            return undefined;
+        }
+        // Get the type arguments inferred by the checker
+        const typeArgs = [];
+        for (const typeParam of typeParameters) {
+            // Try to resolve the instantiated type for this parameter
+            const typeNode = checker.typeToTypeNode(typeParam, node, ts.NodeBuilderFlags.None);
+            if (typeNode) {
+                typeArgs.push(convertType(typeNode, checker));
+            }
+        }
+        return typeArgs.length > 0 ? typeArgs : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Check if a call/new expression requires specialization
+ * Returns true for conditional types, infer, variadic generics, this typing
+ */
+export const checkIfRequiresSpecialization = (node, checker) => {
+    try {
+        const signature = checker.getResolvedSignature(node);
+        if (!signature || !signature.declaration) {
+            return false;
+        }
+        const decl = signature.declaration;
+        // Check for conditional return types
+        if (ts.isFunctionDeclaration(decl) ||
+            ts.isMethodDeclaration(decl) ||
+            ts.isFunctionTypeNode(decl)) {
+            if (decl.type && ts.isConditionalTypeNode(decl.type)) {
+                return true;
+            }
+        }
+        // Check for variadic type parameters (rest parameters with generic types)
+        const typeParameters = signature.typeParameters;
+        if (typeParameters) {
+            for (const typeParam of typeParameters) {
+                const constraint = typeParam.getConstraint();
+                if (constraint) {
+                    const constraintStr = checker.typeToString(constraint);
+                    // Check for unknown[] which indicates variadic
+                    if (constraintStr.includes("unknown[]") ||
+                        constraintStr.includes("any[]")) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Convert TypeScript binary operator token to string
+ */
+export const convertBinaryOperator = (token) => {
+    const operatorMap = {
+        [ts.SyntaxKind.PlusToken]: "+",
+        [ts.SyntaxKind.MinusToken]: "-",
+        [ts.SyntaxKind.AsteriskToken]: "*",
+        [ts.SyntaxKind.SlashToken]: "/",
+        [ts.SyntaxKind.PercentToken]: "%",
+        [ts.SyntaxKind.AsteriskAsteriskToken]: "**",
+        [ts.SyntaxKind.EqualsEqualsToken]: "==",
+        [ts.SyntaxKind.ExclamationEqualsToken]: "!=",
+        [ts.SyntaxKind.EqualsEqualsEqualsToken]: "===",
+        [ts.SyntaxKind.ExclamationEqualsEqualsToken]: "!==",
+        [ts.SyntaxKind.LessThanToken]: "<",
+        [ts.SyntaxKind.GreaterThanToken]: ">",
+        [ts.SyntaxKind.LessThanEqualsToken]: "<=",
+        [ts.SyntaxKind.GreaterThanEqualsToken]: ">=",
+        [ts.SyntaxKind.LessThanLessThanToken]: "<<",
+        [ts.SyntaxKind.GreaterThanGreaterThanToken]: ">>",
+        [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: ">>>",
+        [ts.SyntaxKind.AmpersandToken]: "&",
+        [ts.SyntaxKind.BarToken]: "|",
+        [ts.SyntaxKind.CaretToken]: "^",
+        [ts.SyntaxKind.AmpersandAmpersandToken]: "&&",
+        [ts.SyntaxKind.BarBarToken]: "||",
+        [ts.SyntaxKind.QuestionQuestionToken]: "??",
+        [ts.SyntaxKind.InKeyword]: "in",
+        [ts.SyntaxKind.InstanceOfKeyword]: "instanceof",
+        [ts.SyntaxKind.EqualsToken]: "=",
+        [ts.SyntaxKind.PlusEqualsToken]: "+=",
+        [ts.SyntaxKind.MinusEqualsToken]: "-=",
+        [ts.SyntaxKind.AsteriskEqualsToken]: "*=",
+        [ts.SyntaxKind.SlashEqualsToken]: "/=",
+        [ts.SyntaxKind.PercentEqualsToken]: "%=",
+        [ts.SyntaxKind.AsteriskAsteriskEqualsToken]: "**=",
+        [ts.SyntaxKind.LessThanLessThanEqualsToken]: "<<=",
+        [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken]: ">>=",
+        [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: ">>>=",
+        [ts.SyntaxKind.AmpersandEqualsToken]: "&=",
+        [ts.SyntaxKind.BarEqualsToken]: "|=",
+        [ts.SyntaxKind.CaretEqualsToken]: "^=",
+        [ts.SyntaxKind.AmpersandAmpersandEqualsToken]: "&&=",
+        [ts.SyntaxKind.BarBarEqualsToken]: "||=",
+        [ts.SyntaxKind.QuestionQuestionEqualsToken]: "??=",
+    };
+    return operatorMap[token.kind] ?? "=";
+};
+/**
+ * Check if a binary operator token is an assignment operator
+ */
+export const isAssignmentOperator = (token) => {
+    return (token.kind >= ts.SyntaxKind.FirstAssignment &&
+        token.kind <= ts.SyntaxKind.LastAssignment);
+};
+/**
+ * Get the contextual type for an expression (for object literals).
+ * Returns an IrType with type arguments if the contextual type is a named type
+ * (interface, class, generic), or undefined if it's an anonymous/primitive type.
+ *
+ * This captures the full type including generic type arguments (e.g., Container<T>),
+ * which is essential for emitting correct C# object initializers.
+ */
+export const getContextualType = (node, checker) => {
+    try {
+        const contextualType = checker.getContextualType(node);
+        if (!contextualType) {
+            return undefined;
+        }
+        // Check if it's an object type with a symbol (named type)
+        const symbol = contextualType.getSymbol();
+        if (!symbol) {
+            return undefined;
+        }
+        // Get the symbol name
+        const name = symbol.getName();
+        // Skip anonymous types and built-in types
+        if (name === "__type" || name === "__object" || name === "Object") {
+            return undefined;
+        }
+        // Check that it's actually a class or interface declaration
+        const declarations = symbol.getDeclarations();
+        if (declarations && declarations.length > 0) {
+            const firstDecl = declarations[0];
+            if (firstDecl &&
+                (ts.isInterfaceDeclaration(firstDecl) ||
+                    ts.isClassDeclaration(firstDecl) ||
+                    ts.isTypeAliasDeclaration(firstDecl))) {
+                // Convert the full contextual type to IR, capturing type arguments
+                return convertTsTypeToIr(contextualType, checker);
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * @deprecated Use getContextualType instead - returns IrType with type arguments
+ */
+export const getContextualTypeName = (node, checker) => {
+    const irType = getContextualType(node, checker);
+    if (irType && irType.kind === "referenceType") {
+        return irType.name;
+    }
+    return undefined;
+};
+//# sourceMappingURL=helpers.js.map

package/dist/ir/converters/expressions/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/helpers.ts"],"names":[],"mappings":"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"}

package/dist/ir/converters/expressions/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Expression converters barrel exports
+ */
+export { getInferredType, extractTypeArguments, checkIfRequiresSpecialization, convertBinaryOperator, isAssignmentOperator, } from "./helpers.js";
+export { convertLiteral } from "./literals.js";
+export { convertArrayLiteral, convertObjectLiteral } from "./collections.js";
+export { convertMemberExpression } from "./access.js";
+export { convertCallExpression, convertNewExpression } from "./calls.js";
+export { convertBinaryExpression, convertUnaryExpression, convertUpdateExpression, } from "./operators.js";
+export { convertFunctionExpression, convertArrowFunction, } from "./functions.js";
+export { convertConditionalExpression, convertTemplateLiteral, } from "./other.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ir/converters/expressions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,6BAA6B,EAC7B,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGtD,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGzE,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,YAAY,CAAC"}

package/dist/ir/converters/expressions/index.js

@@ -0,0 +1,20 @@
+/**
+ * Expression converters barrel exports
+ */
+// Helpers
+export { getInferredType, extractTypeArguments, checkIfRequiresSpecialization, convertBinaryOperator, isAssignmentOperator, } from "./helpers.js";
+// Literals
+export { convertLiteral } from "./literals.js";
+// Collections
+export { convertArrayLiteral, convertObjectLiteral } from "./collections.js";
+// Member access
+export { convertMemberExpression } from "./access.js";
+// Calls
+export { convertCallExpression, convertNewExpression } from "./calls.js";
+// Operators
+export { convertBinaryExpression, convertUnaryExpression, convertUpdateExpression, } from "./operators.js";
+// Functions
+export { convertFunctionExpression, convertArrowFunction, } from "./functions.js";
+// Other
+export { convertConditionalExpression, convertTemplateLiteral, } from "./other.js";
+//# sourceMappingURL=index.js.map

package/dist/ir/converters/expressions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,UAAU;AACV,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,6BAA6B,EAC7B,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,WAAW;AACX,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,cAAc;AACd,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7E,gBAAgB;AAChB,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEtD,QAAQ;AACR,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEzE,YAAY;AACZ,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AAExB,YAAY;AACZ,OAAO,EACL,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,QAAQ;AACR,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,YAAY,CAAC"}

package/dist/ir/converters/expressions/literals.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Literal expression converters
+ */
+import * as ts from "typescript";
+import { IrLiteralExpression } from "../../types.js";
+/**
+ * Convert string or numeric literal
+ */
+export declare const convertLiteral: (node: ts.StringLiteral | ts.NumericLiteral, checker: ts.TypeChecker) => IrLiteralExpression;
+//# sourceMappingURL=literals.d.ts.map

package/dist/ir/converters/expressions/literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/literals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,EAC1C,SAAS,EAAE,CAAC,WAAW,KACtB,mBAOF,CAAC"}

package/dist/ir/converters/expressions/literals.js

@@ -0,0 +1,17 @@
+/**
+ * Literal expression converters
+ */
+import * as ts from "typescript";
+import { getInferredType } from "./helpers.js";
+/**
+ * Convert string or numeric literal
+ */
+export const convertLiteral = (node, checker) => {
+    return {
+        kind: "literal",
+        value: ts.isStringLiteral(node) ? node.text : Number(node.text),
+        raw: node.getText(),
+        inferredType: getInferredType(node, checker),
+    };
+};
+//# sourceMappingURL=literals.js.map

package/dist/ir/converters/expressions/literals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/literals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,IAA0C,EAC1C,OAAuB,EACF,EAAE;IACvB,OAAO;QACL,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;QAC/D,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE;QACnB,YAAY,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC;KAC7C,CAAC;AACJ,CAAC,CAAC"}

package/dist/ir/converters/expressions/operators.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Operator expression converters (binary, unary, update, assignment)
+ */
+import * as ts from "typescript";
+import { IrExpression, IrUnaryExpression, IrUpdateExpression } from "../../types.js";
+/**
+ * Convert binary expression (including logical and assignment)
+ */
+export declare const convertBinaryExpression: (node: ts.BinaryExpression, checker: ts.TypeChecker) => IrExpression;
+/**
+ * Convert prefix unary expression
+ */
+export declare const convertUnaryExpression: (node: ts.PrefixUnaryExpression, checker: ts.TypeChecker) => IrUnaryExpression | IrUpdateExpression;
+/**
+ * Convert postfix unary expression (++ or --)
+ */
+export declare const convertUpdateExpression: (node: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression, checker: ts.TypeChecker) => IrUpdateExpression;
+//# sourceMappingURL=operators.d.ts.map

package/dist/ir/converters/expressions/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/operators.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAGnB,MAAM,gBAAgB,CAAC;AAQxB;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,EAAE,CAAC,gBAAgB,EACzB,SAAS,EAAE,CAAC,WAAW,KACtB,YAoCF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,EAAE,CAAC,qBAAqB,EAC9B,SAAS,EAAE,CAAC,WAAW,KACtB,iBAAiB,GAAG,kBAyCtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,EAAE,CAAC,sBAAsB,GAAG,EAAE,CAAC,qBAAqB,EAC1D,SAAS,EAAE,CAAC,WAAW,KACtB,kBA4BF,CAAC"}

package/dist/ir/converters/expressions/operators.js

@@ -0,0 +1,111 @@
+/**
+ * Operator expression converters (binary, unary, update, assignment)
+ */
+import * as ts from "typescript";
+import { getInferredType, convertBinaryOperator, isAssignmentOperator, } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+/**
+ * Convert binary expression (including logical and assignment)
+ */
+export const convertBinaryExpression = (node, checker) => {
+    const operator = convertBinaryOperator(node.operatorToken);
+    const inferredType = getInferredType(node, checker);
+    // Handle assignment separately
+    if (isAssignmentOperator(node.operatorToken)) {
+        return {
+            kind: "assignment",
+            operator: operator,
+            left: ts.isIdentifier(node.left)
+                ? { kind: "identifier", name: node.left.text }
+                : convertExpression(node.left, checker),
+            right: convertExpression(node.right, checker),
+            inferredType,
+        };
+    }
+    // Handle logical operators
+    if (operator === "&&" || operator === "||" || operator === "??") {
+        return {
+            kind: "logical",
+            operator,
+            left: convertExpression(node.left, checker),
+            right: convertExpression(node.right, checker),
+            inferredType,
+        };
+    }
+    // Regular binary expression
+    return {
+        kind: "binary",
+        operator: operator,
+        left: convertExpression(node.left, checker),
+        right: convertExpression(node.right, checker),
+        inferredType,
+    };
+};
+/**
+ * Convert prefix unary expression
+ */
+export const convertUnaryExpression = (node, checker) => {
+    const inferredType = getInferredType(node, checker);
+    // Check if it's an increment/decrement (++ or --)
+    if (node.operator === ts.SyntaxKind.PlusPlusToken ||
+        node.operator === ts.SyntaxKind.MinusMinusToken) {
+        return {
+            kind: "update",
+            operator: node.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+            prefix: true,
+            expression: convertExpression(node.operand, checker),
+            inferredType,
+        };
+    }
+    // Handle regular unary operators
+    let operator = "+";
+    switch (node.operator) {
+        case ts.SyntaxKind.PlusToken:
+            operator = "+";
+            break;
+        case ts.SyntaxKind.MinusToken:
+            operator = "-";
+            break;
+        case ts.SyntaxKind.ExclamationToken:
+            operator = "!";
+            break;
+        case ts.SyntaxKind.TildeToken:
+            operator = "~";
+            break;
+    }
+    return {
+        kind: "unary",
+        operator,
+        expression: convertExpression(node.operand, checker),
+        inferredType,
+    };
+};
+/**
+ * Convert postfix unary expression (++ or --)
+ */
+export const convertUpdateExpression = (node, checker) => {
+    const inferredType = getInferredType(node, checker);
+    if (ts.isPrefixUnaryExpression(node)) {
+        // Check if it's an increment or decrement
+        if (node.operator === ts.SyntaxKind.PlusPlusToken ||
+            node.operator === ts.SyntaxKind.MinusMinusToken) {
+            return {
+                kind: "update",
+                operator: node.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+                prefix: true,
+                expression: convertExpression(node.operand, checker),
+                inferredType,
+            };
+        }
+    }
+    // Handle postfix unary expression
+    const postfix = node;
+    return {
+        kind: "update",
+        operator: postfix.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+        prefix: false,
+        expression: convertExpression(postfix.operand, checker),
+        inferredType,
+    };
+};
+//# sourceMappingURL=operators.js.map

package/dist/ir/converters/expressions/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/operators.ts"],"names":[],"mappings":"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"}

package/dist/ir/converters/expressions/other.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Miscellaneous expression converters (conditional, template literals)
+ */
+import * as ts from "typescript";
+import { IrConditionalExpression, IrTemplateLiteralExpression } from "../../types.js";
+/**
+ * Convert conditional (ternary) expression
+ */
+export declare const convertConditionalExpression: (node: ts.ConditionalExpression, checker: ts.TypeChecker) => IrConditionalExpression;
+/**
+ * Convert template literal expression
+ */
+export declare const convertTemplateLiteral: (node: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral, checker: ts.TypeChecker) => IrTemplateLiteralExpression;
+//# sourceMappingURL=other.d.ts.map

package/dist/ir/converters/expressions/other.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"other.d.ts","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/other.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EACL,uBAAuB,EACvB,2BAA2B,EAE5B,MAAM,gBAAgB,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACvC,MAAM,EAAE,CAAC,qBAAqB,EAC9B,SAAS,EAAE,CAAC,WAAW,KACtB,uBAQF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,EAAE,CAAC,kBAAkB,GAAG,EAAE,CAAC,6BAA6B,EAC9D,SAAS,EAAE,CAAC,WAAW,KACtB,2BAwBF,CAAC"}

package/dist/ir/converters/expressions/other.js

@@ -0,0 +1,44 @@
+/**
+ * Miscellaneous expression converters (conditional, template literals)
+ */
+import * as ts from "typescript";
+import { getInferredType } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+/**
+ * Convert conditional (ternary) expression
+ */
+export const convertConditionalExpression = (node, checker) => {
+    return {
+        kind: "conditional",
+        condition: convertExpression(node.condition, checker),
+        whenTrue: convertExpression(node.whenTrue, checker),
+        whenFalse: convertExpression(node.whenFalse, checker),
+        inferredType: getInferredType(node, checker),
+    };
+};
+/**
+ * Convert template literal expression
+ */
+export const convertTemplateLiteral = (node, checker) => {
+    if (ts.isNoSubstitutionTemplateLiteral(node)) {
+        return {
+            kind: "templateLiteral",
+            quasis: [node.text],
+            expressions: [],
+            inferredType: getInferredType(node, checker),
+        };
+    }
+    const quasis = [node.head.text];
+    const expressions = [];
+    node.templateSpans.forEach((span) => {
+        expressions.push(convertExpression(span.expression, checker));
+        quasis.push(span.literal.text);
+    });
+    return {
+        kind: "templateLiteral",
+        quasis,
+        expressions,
+        inferredType: getInferredType(node, checker),
+    };
+};
+//# sourceMappingURL=other.js.map

package/dist/ir/converters/expressions/other.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"other.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/other.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAMjC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,IAA8B,EAC9B,OAAuB,EACE,EAAE;IAC3B,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC;QACrD,QAAQ,EAAE,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;QACnD,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC;QACrD,YAAY,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC;KAC7C,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,IAA8D,EAC9D,OAAuB,EACM,EAAE;IAC/B,IAAI,EAAE,CAAC,+BAA+B,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,OAAO;YACL,IAAI,EAAE,iBAAiB;YACvB,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;YACnB,WAAW,EAAE,EAAE;YACf,YAAY,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,WAAW,GAAmB,EAAE,CAAC;IAEvC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAClC,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,MAAM;QACN,WAAW;QACX,YAAY,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC;KAC7C,CAAC;AACJ,CAAC,CAAC"}

package/dist/ir/converters/statements/control/blocks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Block statement converter
+ */
+import * as ts from "typescript";
+import { IrBlockStatement } from "../../../types.js";
+/**
+ * Convert block statement
+ */
+export declare const convertBlockStatement: (node: ts.Block, checker: ts.TypeChecker) => IrBlockStatement;
+//# sourceMappingURL=blocks.d.ts.map

package/dist/ir/converters/statements/control/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../../../src/ir/converters/statements/control/blocks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAe,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGlE;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,EAAE,CAAC,KAAK,EACd,SAAS,EAAE,CAAC,WAAW,KACtB,gBAOF,CAAC"}

package/dist/ir/converters/statements/control/blocks.js

@@ -0,0 +1,16 @@
+/**
+ * Block statement converter
+ */
+import { convertStatement } from "../../../statement-converter.js";
+/**
+ * Convert block statement
+ */
+export const convertBlockStatement = (node, checker) => {
+    return {
+        kind: "blockStatement",
+        statements: node.statements
+            .map((s) => convertStatement(s, checker))
+            .filter((s) => s !== null),
+    };
+};
+//# sourceMappingURL=blocks.js.map

package/dist/ir/converters/statements/control/blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","sourceRoot":"","sources":["../../../../../src/ir/converters/statements/control/blocks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,IAAc,EACd,OAAuB,EACL,EAAE;IACpB,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,UAAU,EAAE,IAAI,CAAC,UAAU;aACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;aACxC,MAAM,CAAC,CAAC,CAAC,EAAoB,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC;KAC/C,CAAC;AACJ,CAAC,CAAC"}

package/dist/ir/converters/statements/control/conditionals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Conditional statement converters (if, switch)
+ */
+import * as ts from "typescript";
+import { IrIfStatement, IrSwitchStatement, IrSwitchCase } from "../../../types.js";
+/**
+ * Convert if statement
+ */
+export declare const convertIfStatement: (node: ts.IfStatement, checker: ts.TypeChecker) => IrIfStatement;
+/**
+ * Convert switch statement
+ */
+export declare const convertSwitchStatement: (node: ts.SwitchStatement, checker: ts.TypeChecker) => IrSwitchStatement;
+/**
+ * Convert switch case
+ */
+export declare const convertSwitchCase: (node: ts.CaseOrDefaultClause, checker: ts.TypeChecker) => IrSwitchCase;
+//# sourceMappingURL=conditionals.d.ts.map

package/dist/ir/converters/statements/control/conditionals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.d.ts","sourceRoot":"","sources":["../../../../../src/ir/converters/statements/control/conditionals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAEL,aAAa,EACb,iBAAiB,EACjB,YAAY,EACb,MAAM,mBAAmB,CAAC;AAI3B;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,EAAE,CAAC,WAAW,EACpB,SAAS,EAAE,CAAC,WAAW,KACtB,aAYF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,EAAE,CAAC,eAAe,EACxB,SAAS,EAAE,CAAC,WAAW,KACtB,iBAQF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,EAAE,CAAC,mBAAmB,EAC5B,SAAS,EAAE,CAAC,WAAW,KACtB,YAUF,CAAC"}

package/dist/ir/converters/statements/control/conditionals.js

@@ -0,0 +1,46 @@
+/**
+ * Conditional statement converters (if, switch)
+ */
+import * as ts from "typescript";
+import { convertExpression } from "../../../expression-converter.js";
+import { convertStatement } from "../../../statement-converter.js";
+/**
+ * Convert if statement
+ */
+export const convertIfStatement = (node, checker) => {
+    const thenStmt = convertStatement(node.thenStatement, checker);
+    const elseStmt = node.elseStatement
+        ? convertStatement(node.elseStatement, checker)
+        : undefined;
+    return {
+        kind: "ifStatement",
+        condition: convertExpression(node.expression, checker),
+        thenStatement: thenStmt ?? { kind: "emptyStatement" },
+        elseStatement: elseStmt ?? undefined,
+    };
+};
+/**
+ * Convert switch statement
+ */
+export const convertSwitchStatement = (node, checker) => {
+    return {
+        kind: "switchStatement",
+        expression: convertExpression(node.expression, checker),
+        cases: node.caseBlock.clauses.map((clause) => convertSwitchCase(clause, checker)),
+    };
+};
+/**
+ * Convert switch case
+ */
+export const convertSwitchCase = (node, checker) => {
+    return {
+        kind: "switchCase",
+        test: ts.isCaseClause(node)
+            ? convertExpression(node.expression, checker)
+            : undefined,
+        statements: node.statements
+            .map((s) => convertStatement(s, checker))
+            .filter((s) => s !== null),
+    };
+};
+//# sourceMappingURL=conditionals.js.map

package/dist/ir/converters/statements/control/conditionals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.js","sourceRoot":"","sources":["../../../../../src/ir/converters/statements/control/conditionals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAOjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,IAAoB,EACpB,OAAuB,EACR,EAAE;IACjB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa;QACjC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC;QAC/C,CAAC,CAAC,SAAS,CAAC;IAEd,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;QACtD,aAAa,EAAE,QAAQ,IAAI,EAAE,IAAI,EAAE,gBAAgB,EAAE;QACrD,aAAa,EAAE,QAAQ,IAAI,SAAS;KACrC,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,IAAwB,EACxB,OAAuB,EACJ,EAAE;IACrB,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,UAAU,EAAE,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;QACvD,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC3C,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,CACnC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,IAA4B,EAC5B,OAAuB,EACT,EAAE;IAChB,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC;YACzB,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;YAC7C,CAAC,CAAC,SAAS;QACb,UAAU,EAAE,IAAI,CAAC,UAAU;aACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;aACxC,MAAM,CAAC,CAAC,CAAC,EAAoB,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC;KAC/C,CAAC;AACJ,CAAC,CAAC"}