semantifold 0.1.0

package/build/src/backends/shared.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Checks the intentionally narrow backend contract.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @returns {void}
+ */
+export declare function validateBackendModule(module: import("../semantic/types.js").SemanticModule, language: import("../semantic/types.js").SemanticLanguage): void;
+/**
+ * Emits a supported expression.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
+ * @param {string} path - Exact JSON Pointer for this expression occurrence.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {(name: string) => string} emitIdentifier - Identifier formatter.
+ * @returns {void}
+ */
+export declare function emitExpression(writer: import("./writer.js").SourceWriter, expression: import("../semantic/types.js").Expression, path: string, language: import("../semantic/types.js").SemanticLanguage, emitIdentifier: (name: string) => string): void;
+/**
+ * Reports whether JavaScript-family execution can create IEEE-754 signed zero.
+ * Semantifold integers have one mathematical zero, so those targets canonicalize
+ * their observable scalar output without changing the operation tree.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic module.
+ * @returns {boolean} Whether canonical output rendering is required.
+ */
+export declare function requiresCanonicalZeroRendering(module: import("../semantic/types.js").SemanticModule): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/build/src/backends/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAJjC,OAAO,sBAAsB,EAAE,cAIE,EAAE,QAAQ,EAH3C,OAAO,sBAAsB,EAAE,gBAGY,GAFzC,IAAI,CAuBhB;AA4PD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAP1B,OAAO,aAAa,EAAE,YAOI,EAAE,UAAU,EANtC,OAAO,sBAAsB,EAAE,UAMO,EAAE,IAAI,EAL5C,MAK4C,EAAE,QAAQ,EAJtD,OAAO,sBAAsB,EAAE,gBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CAwEhB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}

package/build/src/backends/shared.js

@@ -0,0 +1,424 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { validateBackendTypes } from "../semantic/validate.js";
+import { validateTargetBindingIdentifier, validateTargetIdentifier } from "./identifiers.js";
+import { emitStringLiteral } from "./scalars.js";
+/** @type {Readonly<Record<import("../semantic/types.js").SemanticUnaryOperation, string>>} */
+const unaryOperationSyntax = Object.freeze({ BooleanNot: "!", IntegerNegate: "-" });
+/** @type {Readonly<Record<import("../semantic/types.js").SemanticBinaryOperation, Readonly<{default: string, php?: string, strict?: string}>>>} */
+const binaryOperationSyntax = Object.freeze({
+    BooleanAnd: Object.freeze({ default: "&&" }),
+    BooleanEqual: Object.freeze({ default: "==", strict: "===" }),
+    BooleanNotEqual: Object.freeze({ default: "!=", strict: "!==" }),
+    BooleanOr: Object.freeze({ default: "||" }),
+    IntegerAdd: Object.freeze({ default: "+" }),
+    IntegerEqual: Object.freeze({ default: "==", strict: "===" }),
+    IntegerGreaterThan: Object.freeze({ default: ">" }),
+    IntegerGreaterThanOrEqual: Object.freeze({ default: ">=" }),
+    IntegerLessThan: Object.freeze({ default: "<" }),
+    IntegerLessThanOrEqual: Object.freeze({ default: "<=" }),
+    IntegerMultiply: Object.freeze({ default: "*" }),
+    IntegerNotEqual: Object.freeze({ default: "!=", strict: "!==" }),
+    IntegerSubtract: Object.freeze({ default: "-" }),
+    StringConcat: Object.freeze({ default: "+", php: "." }),
+    StringEqual: Object.freeze({ default: "==", strict: "===" }),
+    StringNotEqual: Object.freeze({ default: "!=", strict: "!==" })
+});
+/**
+ * Checks the intentionally narrow backend contract.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @returns {void}
+ */
+export function validateBackendModule(module, language) {
+    if (module.kind != "Module")
+        unsupportedCapability(language, module.kind, module.location);
+    if (module.functions.length == 0)
+        unsupportedCapability(language, "module without functions", module.location);
+    validateBlock(module.entryPoint.body, language, module.entryPoint.location);
+    for (const functionDeclaration of module.functions) {
+        validateTargetBindingIdentifier(language, functionDeclaration.name, "function", functionDeclaration.location);
+        if (functionDeclaration.parameters.length != 2) {
+            unsupportedCapability(language, "function parameter count other than two", functionDeclaration.location);
+        }
+        validateBlock(functionDeclaration.body, language, functionDeclaration.location);
+        for (const parameter of functionDeclaration.parameters) {
+            validateTargetBindingIdentifier(language, parameter.name, "parameter", parameter.location);
+        }
+    }
+    validateScaffoldingNames(module, language);
+    validateBackendTypes(module, language);
+}
+/**
+ * Rejects semantic names that would capture syntax owned by one backend emitter.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @returns {void}
+ */
+function validateScaffoldingNames(module, language) {
+    const ownedEntryNames = language == "java" ? new Set(["args", "System"]) :
+        ["javascript", "typescript"].includes(language) ? new Set(["console"]) : new Set();
+    const ownedPrintReceiverNames = language == "java" ? new Set(["System"]) :
+        ["javascript", "typescript"].includes(language) ? new Set(["console"]) : new Set();
+    const ownedCallableNames = ["javascript", "typescript"].includes(language) ? new Set(["console"]) :
+        language == "ruby" ? new Set(["puts"]) : new Set();
+    for (const statement of allStatements(module.entryPoint.body)) {
+        if (statement.kind == "LocalDeclaration" && ownedEntryNames.has(statement.name)) {
+            unsupportedCapability(language, `entry local '${statement.name}' captures backend scaffolding`, statement.location);
+        }
+    }
+    for (const declaration of module.functions) {
+        if (ownedCallableNames.has(declaration.name)) {
+            unsupportedCapability(language, `function '${declaration.name}' captures backend scaffolding`, declaration.location);
+        }
+        for (const parameter of declaration.parameters) {
+            if (ownedPrintReceiverNames.has(parameter.name)) {
+                unsupportedCapability(language, `function parameter '${parameter.name}' captures backend scaffolding`, parameter.location);
+            }
+        }
+        for (const statement of allStatements(declaration.body)) {
+            if (statement.kind == "LocalDeclaration" && ownedPrintReceiverNames.has(statement.name)) {
+                unsupportedCapability(language, `function local '${statement.name}' captures backend scaffolding`, statement.location);
+            }
+        }
+    }
+}
+/**
+ * Returns every statement nested beneath a block in semantic order.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @returns {import("../semantic/types.js").Statement[]} Statements including nested branches.
+ */
+function allStatements(block) {
+    return block.statements.flatMap((statement) => statement.kind == "IfStatement"
+        ? [statement, ...allStatements(statement.consequent), ...(statement.alternate ? allStatements(statement.alternate) : [])]
+        : [statement]);
+}
+/**
+ * Validates one complete semantic block before emission.
+ * @param {unknown} block - Candidate block.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Enclosing location.
+ * @returns {void}
+ */
+function validateBlock(block, language, ownerLocation) {
+    if (!block || typeof block != "object" || Array.isArray(block)) {
+        return unsupportedCapability(language, "missing or invalid block", ownerLocation);
+    }
+    const candidate = /** @type {import("../semantic/types.js").Block} */ (block);
+    const location = candidate.location ?? ownerLocation;
+    if (candidate.kind != "Block")
+        unsupportedCapability(language, `block ${String(Reflect.get(block, "kind"))}`, location);
+    if (!Array.isArray(candidate.statements))
+        unsupportedCapability(language, "missing or invalid block statements", location);
+    for (const statement of candidate.statements)
+        validateStatement(statement, language, location);
+}
+/**
+ * Validates one supported statement recursively.
+ * @param {unknown} statement - Candidate statement.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Enclosing body location.
+ * @returns {void}
+ */
+function validateStatement(statement, language, ownerLocation) {
+    if (!statement || typeof statement != "object" || Array.isArray(statement)) {
+        return unsupportedCapability(language, "missing or invalid statement", ownerLocation);
+    }
+    const kind = Reflect.get(statement, "kind");
+    const location = /** @type {import("../semantic/types.js").SourceLocation | undefined} */ (Reflect.get(statement, "location") ?? ownerLocation);
+    if (typeof kind != "string")
+        return unsupportedCapability(language, "missing or invalid statement", location);
+    if (kind == "LocalDeclaration") {
+        const declaration = /** @type {import("../semantic/types.js").LocalDeclaration} */ (statement);
+        if (typeof declaration.mutable != "boolean") {
+            unsupportedCapability(language, "local declaration with invalid mutability", location);
+        }
+        validateTargetBindingIdentifier(language, declaration.name, "local", location);
+        validateExpression(declaration.initializer, language, location);
+        return;
+    }
+    if (kind == "AssignmentStatement") {
+        const assignment = /** @type {import("../semantic/types.js").AssignmentStatement} */ (statement);
+        validateAssignmentTarget(assignment.target, language, location);
+        validateExpression(assignment.expression, language, location);
+        return;
+    }
+    if (kind == "ReturnStatement" || kind == "PrintStatement") {
+        validateExpression(Reflect.get(statement, "expression"), language, location);
+        return;
+    }
+    if (kind == "IfStatement") {
+        const branch = /** @type {import("../semantic/types.js").IfStatement} */ (statement);
+        validateExpression(branch.condition, language, location);
+        validateBlock(branch.consequent, language, location);
+        if (Object.hasOwn(branch, "alternate"))
+            validateBlock(branch.alternate, language, location);
+        return;
+    }
+    unsupportedCapability(language, `statement ${kind}`, location);
+}
+/**
+ * Validates the simple identifier target introduced by task 002.
+ * @param {unknown} target - Candidate assignment target.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Assignment location.
+ * @returns {void}
+ */
+function validateAssignmentTarget(target, language, ownerLocation) {
+    if (!target || typeof target != "object" || Array.isArray(target)) {
+        return unsupportedCapability(language, "missing or invalid assignment target", ownerLocation);
+    }
+    const candidate = /** @type {import("../semantic/types.js").IdentifierExpression} */ (target);
+    const location = candidate.location ?? ownerLocation;
+    if (candidate.kind != "IdentifierExpression") {
+        return unsupportedCapability(language, `assignment target ${String(Reflect.get(target, "kind"))}`, location);
+    }
+    validateTargetBindingIdentifier(language, candidate.name, "assignment target", location);
+}
+/**
+ * Checks expression backend capabilities recursively.
+ * @param {unknown} expression - Candidate semantic expression.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Nearest owning node location.
+ * @param {boolean} [allowJavaNegatedMinimumOperand] - Whether Java may use 2147483648 only beneath integer negation.
+ * @returns {void}
+ */
+function validateExpression(expression, language, ownerLocation, allowJavaNegatedMinimumOperand = false) {
+    if (!expression || typeof expression != "object" || Array.isArray(expression)) {
+        return unsupportedCapability(language, "missing or invalid expression", ownerLocation);
+    }
+    const candidate = /** @type {import("../semantic/types.js").Expression} */ (expression);
+    const location = candidate.location ?? ownerLocation;
+    if (typeof candidate.kind != "string") {
+        return unsupportedCapability(language, "missing or invalid expression", location);
+    }
+    if (candidate.kind == "IdentifierExpression") {
+        validateTargetIdentifier(language, candidate.name, "reference", location);
+        return;
+    }
+    if (candidate.kind == "IntegerLiteral") {
+        if (!Number.isSafeInteger(candidate.value)) {
+            unsupportedCapability(language, "non-safe integer literal", location);
+        }
+        const validNegatedMinimumOperand = allowJavaNegatedMinimumOperand && candidate.value == 2147483648;
+        if (language == "java" && !validNegatedMinimumOperand && (candidate.value < -2147483648 || candidate.value > 2147483647)) {
+            unsupportedCapability(language, "integer literal outside signed 32-bit int range", location);
+        }
+        return;
+    }
+    if (candidate.kind == "BooleanLiteral" || candidate.kind == "StringLiteral")
+        return;
+    if (candidate.kind == "CallExpression") {
+        validateTargetIdentifier(language, candidate.callee, "callee", location);
+        if (!Array.isArray(candidate.arguments)) {
+            unsupportedCapability(language, "missing or invalid call arguments", location);
+        }
+        if (candidate.arguments.length != 2) {
+            unsupportedCapability(language, "call argument count other than two", location);
+        }
+        for (const argument of candidate.arguments)
+            validateExpression(argument, language, location);
+        return;
+    }
+    if (candidate.kind == "UnaryExpression") {
+        if (!Object.hasOwn(unaryOperationSyntax, String(candidate.operation))) {
+            unsupportedCapability(language, `unary operation ${String(candidate.operation)}`, location);
+        }
+        validateExpression(candidate.operand, language, location, candidate.operation == "IntegerNegate");
+        validateKnownJavaInteger(candidate, language, location);
+        return;
+    }
+    if (candidate.kind == "BinaryExpression") {
+        if (!Object.hasOwn(binaryOperationSyntax, String(candidate.operation))) {
+            unsupportedCapability(language, `binary operation ${String(candidate.operation)}`, location);
+        }
+        validateExpression(candidate.left, language, location);
+        validateExpression(candidate.right, language, location);
+        validateKnownJavaInteger(candidate, language, location);
+        return;
+    }
+    unsupportedCapability(language, String(Reflect.get(expression, "kind")), location);
+}
+/**
+ * Rejects compile-time-known Java integer operation results outside primitive int.
+ * @param {import("../semantic/types.js").UnaryExpression | import("../semantic/types.js").BinaryExpression} expression - Validated operation shape.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Operation location.
+ * @returns {void}
+ */
+function validateKnownJavaInteger(expression, language, location) {
+    if (language != "java")
+        return;
+    const value = knownIntegerValue(expression);
+    if (value !== undefined && (value < -2147483648n || value > 2147483647n)) {
+        unsupportedCapability(language, "compile-time-known integer operation outside signed 32-bit int range", location);
+    }
+}
+/**
+ * Evaluates only literal integer-operation trees for bounds validation, never IR folding.
+ * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
+ * @returns {bigint | undefined} Known mathematical integer.
+ */
+function knownIntegerValue(expression) {
+    if (expression.kind == "IntegerLiteral" && Number.isSafeInteger(expression.value))
+        return BigInt(expression.value);
+    if (expression.kind == "UnaryExpression" && expression.operation == "IntegerNegate") {
+        const operand = knownIntegerValue(expression.operand);
+        return operand === undefined ? undefined : -operand;
+    }
+    if (expression.kind != "BinaryExpression")
+        return undefined;
+    const left = knownIntegerValue(expression.left);
+    const right = knownIntegerValue(expression.right);
+    if (left === undefined || right === undefined)
+        return undefined;
+    if (expression.operation == "IntegerAdd")
+        return left + right;
+    if (expression.operation == "IntegerSubtract")
+        return left - right;
+    if (expression.operation == "IntegerMultiply")
+        return left * right;
+    return undefined;
+}
+/**
+ * Emits a supported expression.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
+ * @param {string} path - Exact JSON Pointer for this expression occurrence.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {(name: string) => string} emitIdentifier - Identifier formatter.
+ * @returns {void}
+ */
+export function emitExpression(writer, expression, path, language, emitIdentifier) {
+    if (expression.kind == "IdentifierExpression") {
+        writer.mapped(emitIdentifier(expression.name), { mappingKind: "exact", node: expression, path, role: "name" });
+        return;
+    }
+    if (expression.kind == "IntegerLiteral") {
+        writer.mapped(String(expression.value), { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "BooleanLiteral") {
+        writer.mapped(expression.value ? "true" : "false", { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "StringLiteral") {
+        writer.mapped(emitStringLiteral(language, expression.value), { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "CallExpression") {
+        writer.mapped(expression.callee, { mappingKind: "exact", node: expression, path, role: "callee" });
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        expression.arguments.forEach((argument, index) => {
+            if (index > 0)
+                writer.synthetic(", ", "argument separator", [expression], [path]);
+            emitExpression(writer, argument, `${path}/arguments/${index}`, language, emitIdentifier);
+        });
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        return;
+    }
+    if (expression.kind == "UnaryExpression") {
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        writer.mapped(unaryOperationSyntax[expression.operation], {
+            mappingKind: "exact", node: expression, path, role: "operator"
+        });
+        emitExpression(writer, expression.operand, `${path}/operand`, language, emitIdentifier);
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        return;
+    }
+    if (language == "java" && (expression.operation == "StringEqual" || expression.operation == "StringNotEqual")) {
+        const compositeOperator = expression.operation == "StringNotEqual" && writer.hasRange(expression, path, "equalityOperator");
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        if (expression.operation == "StringNotEqual") {
+            writer.mapped("!", { mappingKind: "exact", node: expression, path, role: "operator" });
+        }
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier);
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        writer.mapped(".equals", {
+            mappingKind: "exact", node: expression, path, role: compositeOperator ? "equalityOperator" : "operator"
+        });
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier);
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        return;
+    }
+    writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+    emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier);
+    writer.synthetic(" ", "operator spacing", [expression], [path]);
+    const spelling = binaryOperationSpelling(expression.operation, language);
+    if (expression.operation == "StringNotEqual" && writer.hasRange(expression, path, "equalityOperator")) {
+        writer.mapped(spelling.slice(0, 1), { mappingKind: "exact", node: expression, path, role: "operator" });
+        writer.mapped(spelling.slice(1), { mappingKind: "exact", node: expression, path, role: "equalityOperator" });
+    }
+    else
+        writer.mapped(spelling, { mappingKind: "exact", node: expression, path, role: "operator" });
+    writer.synthetic(" ", "operator spacing", [expression], [path]);
+    emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier);
+    writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+}
+/**
+ * Reports whether JavaScript-family execution can create IEEE-754 signed zero.
+ * Semantifold integers have one mathematical zero, so those targets canonicalize
+ * their observable scalar output without changing the operation tree.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic module.
+ * @returns {boolean} Whether canonical output rendering is required.
+ */
+export function requiresCanonicalZeroRendering(module) {
+    return module.functions.some((declaration) => blockContainsSignProducingOperation(declaration.body)) ||
+        blockContainsSignProducingOperation(module.entryPoint.body);
+}
+/**
+ * Checks one block for sign-producing integer operations.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @returns {boolean} Whether a nested expression can produce signed zero in JavaScript.
+ */
+function blockContainsSignProducingOperation(block) {
+    return block.statements.some((statement) => {
+        if (statement.kind == "IfStatement") {
+            return expressionContainsSignProducingOperation(statement.condition) ||
+                blockContainsSignProducingOperation(statement.consequent) ||
+                Boolean(statement.alternate && blockContainsSignProducingOperation(statement.alternate));
+        }
+        if (statement.kind == "LocalDeclaration")
+            return expressionContainsSignProducingOperation(statement.initializer);
+        if (statement.kind == "AssignmentStatement" || statement.kind == "ReturnStatement" || statement.kind == "PrintStatement") {
+            return expressionContainsSignProducingOperation(statement.expression);
+        }
+        return false;
+    });
+}
+/**
+ * Checks one expression tree for sign-producing integer operations.
+ * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
+ * @returns {boolean} Whether this tree contains integer negation or multiplication.
+ */
+function expressionContainsSignProducingOperation(expression) {
+    if (expression.kind == "UnaryExpression") {
+        return expression.operation == "IntegerNegate" || expressionContainsSignProducingOperation(expression.operand);
+    }
+    if (expression.kind == "BinaryExpression") {
+        return expression.operation == "IntegerMultiply" || expressionContainsSignProducingOperation(expression.left) ||
+            expressionContainsSignProducingOperation(expression.right);
+    }
+    if (expression.kind == "CallExpression") {
+        return expression.arguments.some((argument) => expressionContainsSignProducingOperation(argument));
+    }
+    return false;
+}
+/**
+ * Maps one already validated semantic operation to target syntax.
+ * @param {import("../semantic/types.js").SemanticBinaryOperation} operation - Closed semantic operation.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @returns {string} Target operator spelling.
+ */
+function binaryOperationSpelling(operation, language) {
+    const syntax = binaryOperationSyntax[operation];
+    if (language == "php" && syntax.php)
+        return syntax.php;
+    if ((language == "php" || language == "javascript" || language == "typescript") && syntax.strict)
+        return syntax.strict;
+    return syntax.default;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {validateBackendTypes} from \"../semantic/validate.js\"\nimport {validateTargetBindingIdentifier, validateTargetIdentifier} from \"./identifiers.js\"\nimport {emitStringLiteral} from \"./scalars.js\"\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticUnaryOperation, string>>} */\nconst unaryOperationSyntax = Object.freeze({BooleanNot: \"!\", IntegerNegate: \"-\"})\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticBinaryOperation, Readonly<{default: string, php?: string, strict?: string}>>>} */\nconst binaryOperationSyntax = Object.freeze({\n  BooleanAnd: Object.freeze({default: \"&&\"}),\n  BooleanEqual: Object.freeze({default: \"==\", strict: \"===\"}),\n  BooleanNotEqual: Object.freeze({default: \"!=\", strict: \"!==\"}),\n  BooleanOr: Object.freeze({default: \"||\"}),\n  IntegerAdd: Object.freeze({default: \"+\"}),\n  IntegerEqual: Object.freeze({default: \"==\", strict: \"===\"}),\n  IntegerGreaterThan: Object.freeze({default: \">\"}),\n  IntegerGreaterThanOrEqual: Object.freeze({default: \">=\"}),\n  IntegerLessThan: Object.freeze({default: \"<\"}),\n  IntegerLessThanOrEqual: Object.freeze({default: \"<=\"}),\n  IntegerMultiply: Object.freeze({default: \"*\"}),\n  IntegerNotEqual: Object.freeze({default: \"!=\", strict: \"!==\"}),\n  IntegerSubtract: Object.freeze({default: \"-\"}),\n  StringConcat: Object.freeze({default: \"+\", php: \".\"}),\n  StringEqual: Object.freeze({default: \"==\", strict: \"===\"}),\n  StringNotEqual: Object.freeze({default: \"!=\", strict: \"!==\"})\n})\n\n/**\n * Checks the intentionally narrow backend contract.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @returns {void}\n */\nexport function validateBackendModule(module, language) {\n  if (module.kind != \"Module\") unsupportedCapability(language, module.kind, module.location)\n  if (module.functions.length == 0) unsupportedCapability(language, \"module without functions\", module.location)\n  validateBlock(module.entryPoint.body, language, module.entryPoint.location)\n\n  for (const functionDeclaration of module.functions) {\n    validateTargetBindingIdentifier(language, functionDeclaration.name, \"function\", functionDeclaration.location)\n\n    if (functionDeclaration.parameters.length != 2) {\n      unsupportedCapability(language, \"function parameter count other than two\", functionDeclaration.location)\n    }\n    validateBlock(functionDeclaration.body, language, functionDeclaration.location)\n\n    for (const parameter of functionDeclaration.parameters) {\n      validateTargetBindingIdentifier(language, parameter.name, \"parameter\", parameter.location)\n\n    }\n\n  }\n  validateScaffoldingNames(module, language)\n  validateBackendTypes(module, language)\n}\n\n/**\n * Rejects semantic names that would capture syntax owned by one backend emitter.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @returns {void}\n */\nfunction validateScaffoldingNames(module, language) {\n  const ownedEntryNames = language == \"java\" ? new Set([\"args\", \"System\"]) :\n    [\"javascript\", \"typescript\"].includes(language) ? new Set([\"console\"]) : new Set()\n  const ownedPrintReceiverNames = language == \"java\" ? new Set([\"System\"]) :\n    [\"javascript\", \"typescript\"].includes(language) ? new Set([\"console\"]) : new Set()\n  const ownedCallableNames = [\"javascript\", \"typescript\"].includes(language) ? new Set([\"console\"]) :\n    language == \"ruby\" ? new Set([\"puts\"]) : new Set()\n\n  for (const statement of allStatements(module.entryPoint.body)) {\n    if (statement.kind == \"LocalDeclaration\" && ownedEntryNames.has(statement.name)) {\n      unsupportedCapability(language, `entry local '${statement.name}' captures backend scaffolding`, statement.location)\n    }\n  }\n  for (const declaration of module.functions) {\n    if (ownedCallableNames.has(declaration.name)) {\n      unsupportedCapability(language, `function '${declaration.name}' captures backend scaffolding`, declaration.location)\n    }\n    for (const parameter of declaration.parameters) {\n      if (ownedPrintReceiverNames.has(parameter.name)) {\n        unsupportedCapability(language, `function parameter '${parameter.name}' captures backend scaffolding`, parameter.location)\n      }\n    }\n    for (const statement of allStatements(declaration.body)) {\n      if (statement.kind == \"LocalDeclaration\" && ownedPrintReceiverNames.has(statement.name)) {\n        unsupportedCapability(language, `function local '${statement.name}' captures backend scaffolding`, statement.location)\n      }\n    }\n  }\n}\n\n/**\n * Returns every statement nested beneath a block in semantic order.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @returns {import(\"../semantic/types.js\").Statement[]} Statements including nested branches.\n */\nfunction allStatements(block) {\n  return block.statements.flatMap((statement) => statement.kind == \"IfStatement\"\n    ? [statement, ...allStatements(statement.consequent), ...(statement.alternate ? allStatements(statement.alternate) : [])]\n    : [statement])\n}\n\n/**\n * Validates one complete semantic block before emission.\n * @param {unknown} block - Candidate block.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} ownerLocation - Enclosing location.\n * @returns {void}\n */\nfunction validateBlock(block, language, ownerLocation) {\n  if (!block || typeof block != \"object\" || Array.isArray(block)) {\n    return unsupportedCapability(language, \"missing or invalid block\", ownerLocation)\n  }\n\n  const candidate = /** @type {import(\"../semantic/types.js\").Block} */ (block)\n  const location = candidate.location ?? ownerLocation\n\n  if (candidate.kind != \"Block\") unsupportedCapability(language, `block ${String(Reflect.get(block, \"kind\"))}`, location)\n  if (!Array.isArray(candidate.statements)) unsupportedCapability(language, \"missing or invalid block statements\", location)\n\n  for (const statement of candidate.statements) validateStatement(statement, language, location)\n}\n\n/**\n * Validates one supported statement recursively.\n * @param {unknown} statement - Candidate statement.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} ownerLocation - Enclosing body location.\n * @returns {void}\n */\nfunction validateStatement(statement, language, ownerLocation) {\n  if (!statement || typeof statement != \"object\" || Array.isArray(statement)) {\n    return unsupportedCapability(language, \"missing or invalid statement\", ownerLocation)\n  }\n\n  const kind = Reflect.get(statement, \"kind\")\n  const location = /** @type {import(\"../semantic/types.js\").SourceLocation | undefined} */ (\n    Reflect.get(statement, \"location\") ?? ownerLocation\n  )\n\n  if (typeof kind != \"string\") return unsupportedCapability(language, \"missing or invalid statement\", location)\n  if (kind == \"LocalDeclaration\") {\n    const declaration = /** @type {import(\"../semantic/types.js\").LocalDeclaration} */ (statement)\n\n    if (typeof declaration.mutable != \"boolean\") {\n      unsupportedCapability(language, \"local declaration with invalid mutability\", location)\n    }\n    validateTargetBindingIdentifier(language, declaration.name, \"local\", location)\n    validateExpression(declaration.initializer, language, location)\n    return\n  }\n  if (kind == \"AssignmentStatement\") {\n    const assignment = /** @type {import(\"../semantic/types.js\").AssignmentStatement} */ (statement)\n\n    validateAssignmentTarget(assignment.target, language, location)\n    validateExpression(assignment.expression, language, location)\n    return\n  }\n  if (kind == \"ReturnStatement\" || kind == \"PrintStatement\") {\n    validateExpression(Reflect.get(statement, \"expression\"), language, location)\n    return\n  }\n  if (kind == \"IfStatement\") {\n    const branch = /** @type {import(\"../semantic/types.js\").IfStatement} */ (statement)\n\n    validateExpression(branch.condition, language, location)\n    validateBlock(branch.consequent, language, location)\n    if (Object.hasOwn(branch, \"alternate\")) validateBlock(branch.alternate, language, location)\n    return\n  }\n\n  unsupportedCapability(language, `statement ${kind}`, location)\n}\n\n/**\n * Validates the simple identifier target introduced by task 002.\n * @param {unknown} target - Candidate assignment target.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} ownerLocation - Assignment location.\n * @returns {void}\n */\nfunction validateAssignmentTarget(target, language, ownerLocation) {\n  if (!target || typeof target != \"object\" || Array.isArray(target)) {\n    return unsupportedCapability(language, \"missing or invalid assignment target\", ownerLocation)\n  }\n\n  const candidate = /** @type {import(\"../semantic/types.js\").IdentifierExpression} */ (target)\n  const location = candidate.location ?? ownerLocation\n\n  if (candidate.kind != \"IdentifierExpression\") {\n    return unsupportedCapability(language, `assignment target ${String(Reflect.get(target, \"kind\"))}`, location)\n  }\n\n  validateTargetBindingIdentifier(language, candidate.name, \"assignment target\", location)\n}\n\n/**\n * Checks expression backend capabilities recursively.\n * @param {unknown} expression - Candidate semantic expression.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} ownerLocation - Nearest owning node location.\n * @param {boolean} [allowJavaNegatedMinimumOperand] - Whether Java may use 2147483648 only beneath integer negation.\n * @returns {void}\n */\nfunction validateExpression(expression, language, ownerLocation, allowJavaNegatedMinimumOperand = false) {\n  if (!expression || typeof expression != \"object\" || Array.isArray(expression)) {\n    return unsupportedCapability(language, \"missing or invalid expression\", ownerLocation)\n  }\n\n  const candidate = /** @type {import(\"../semantic/types.js\").Expression} */ (expression)\n  const location = candidate.location ?? ownerLocation\n\n  if (typeof candidate.kind != \"string\") {\n    return unsupportedCapability(language, \"missing or invalid expression\", location)\n  }\n  if (candidate.kind == \"IdentifierExpression\") {\n    validateTargetIdentifier(language, candidate.name, \"reference\", location)\n    return\n  }\n  if (candidate.kind == \"IntegerLiteral\") {\n    if (!Number.isSafeInteger(candidate.value)) {\n      unsupportedCapability(language, \"non-safe integer literal\", location)\n    }\n    const validNegatedMinimumOperand = allowJavaNegatedMinimumOperand && candidate.value == 2147483648\n\n    if (language == \"java\" && !validNegatedMinimumOperand && (candidate.value < -2147483648 || candidate.value > 2147483647)) {\n      unsupportedCapability(language, \"integer literal outside signed 32-bit int range\", location)\n    }\n    return\n  }\n  if (candidate.kind == \"BooleanLiteral\" || candidate.kind == \"StringLiteral\") return\n  if (candidate.kind == \"CallExpression\") {\n    validateTargetIdentifier(language, candidate.callee, \"callee\", location)\n    if (!Array.isArray(candidate.arguments)) {\n      unsupportedCapability(language, \"missing or invalid call arguments\", location)\n    }\n    if (candidate.arguments.length != 2) {\n      unsupportedCapability(language, \"call argument count other than two\", location)\n    }\n    for (const argument of candidate.arguments) validateExpression(argument, language, location)\n    return\n  }\n  if (candidate.kind == \"UnaryExpression\") {\n    if (!Object.hasOwn(unaryOperationSyntax, String(candidate.operation))) {\n      unsupportedCapability(language, `unary operation ${String(candidate.operation)}`, location)\n    }\n    validateExpression(candidate.operand, language, location, candidate.operation == \"IntegerNegate\")\n    validateKnownJavaInteger(candidate, language, location)\n    return\n  }\n  if (candidate.kind == \"BinaryExpression\") {\n    if (!Object.hasOwn(binaryOperationSyntax, String(candidate.operation))) {\n      unsupportedCapability(language, `binary operation ${String(candidate.operation)}`, location)\n    }\n    validateExpression(candidate.left, language, location)\n    validateExpression(candidate.right, language, location)\n    validateKnownJavaInteger(candidate, language, location)\n    return\n  }\n\n  unsupportedCapability(language, String(Reflect.get(expression, \"kind\")), location)\n}\n\n/**\n * Rejects compile-time-known Java integer operation results outside primitive int.\n * @param {import(\"../semantic/types.js\").UnaryExpression | import(\"../semantic/types.js\").BinaryExpression} expression - Validated operation shape.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} location - Operation location.\n * @returns {void}\n */\nfunction validateKnownJavaInteger(expression, language, location) {\n  if (language != \"java\") return\n\n  const value = knownIntegerValue(expression)\n\n  if (value !== undefined && (value < -2147483648n || value > 2147483647n)) {\n    unsupportedCapability(language, \"compile-time-known integer operation outside signed 32-bit int range\", location)\n  }\n}\n\n/**\n * Evaluates only literal integer-operation trees for bounds validation, never IR folding.\n * @param {import(\"../semantic/types.js\").Expression} expression - Semantic expression.\n * @returns {bigint | undefined} Known mathematical integer.\n */\nfunction knownIntegerValue(expression) {\n  if (expression.kind == \"IntegerLiteral\" && Number.isSafeInteger(expression.value)) return BigInt(expression.value)\n  if (expression.kind == \"UnaryExpression\" && expression.operation == \"IntegerNegate\") {\n    const operand = knownIntegerValue(expression.operand)\n\n    return operand === undefined ? undefined : -operand\n  }\n  if (expression.kind != \"BinaryExpression\") return undefined\n\n  const left = knownIntegerValue(expression.left)\n  const right = knownIntegerValue(expression.right)\n\n  if (left === undefined || right === undefined) return undefined\n  if (expression.operation == \"IntegerAdd\") return left + right\n  if (expression.operation == \"IntegerSubtract\") return left - right\n  if (expression.operation == \"IntegerMultiply\") return left * right\n\n  return undefined\n}\n\n/**\n * Emits a supported expression.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Expression} expression - Semantic expression.\n * @param {string} path - Exact JSON Pointer for this expression occurrence.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {(name: string) => string} emitIdentifier - Identifier formatter.\n * @returns {void}\n */\nexport function emitExpression(writer, expression, path, language, emitIdentifier) {\n  if (expression.kind == \"IdentifierExpression\") {\n    writer.mapped(emitIdentifier(expression.name), {mappingKind: \"exact\", node: expression, path, role: \"name\"})\n    return\n  }\n  if (expression.kind == \"IntegerLiteral\") {\n    writer.mapped(String(expression.value), {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"BooleanLiteral\") {\n    writer.mapped(expression.value ? \"true\" : \"false\", {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"StringLiteral\") {\n    writer.mapped(emitStringLiteral(language, expression.value), {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"CallExpression\") {\n    writer.mapped(expression.callee, {mappingKind: \"exact\", node: expression, path, role: \"callee\"})\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    expression.arguments.forEach((argument, index) => {\n      if (index > 0) writer.synthetic(\", \", \"argument separator\", [expression], [path])\n      emitExpression(writer, argument, `${path}/arguments/${index}`, language, emitIdentifier)\n    })\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    return\n  }\n\n  if (expression.kind == \"UnaryExpression\") {\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    writer.mapped(unaryOperationSyntax[expression.operation], {\n      mappingKind: \"exact\", node: expression, path, role: \"operator\"\n    })\n    emitExpression(writer, expression.operand, `${path}/operand`, language, emitIdentifier)\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    return\n  }\n\n  if (language == \"java\" && (expression.operation == \"StringEqual\" || expression.operation == \"StringNotEqual\")) {\n    const compositeOperator = expression.operation == \"StringNotEqual\" && writer.hasRange(expression, path, \"equalityOperator\")\n\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    if (expression.operation == \"StringNotEqual\") {\n      writer.mapped(\"!\", {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n    }\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier)\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    writer.mapped(\".equals\", {\n      mappingKind: \"exact\", node: expression, path, role: compositeOperator ? \"equalityOperator\" : \"operator\"\n    })\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier)\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    return\n  }\n\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n  emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier)\n  writer.synthetic(\" \", \"operator spacing\", [expression], [path])\n  const spelling = binaryOperationSpelling(expression.operation, language)\n\n  if (expression.operation == \"StringNotEqual\" && writer.hasRange(expression, path, \"equalityOperator\")) {\n    writer.mapped(spelling.slice(0, 1), {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n    writer.mapped(spelling.slice(1), {mappingKind: \"exact\", node: expression, path, role: \"equalityOperator\"})\n  } else writer.mapped(spelling, {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n  writer.synthetic(\" \", \"operator spacing\", [expression], [path])\n  emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier)\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n}\n\n/**\n * Reports whether JavaScript-family execution can create IEEE-754 signed zero.\n * Semantifold integers have one mathematical zero, so those targets canonicalize\n * their observable scalar output without changing the operation tree.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated semantic module.\n * @returns {boolean} Whether canonical output rendering is required.\n */\nexport function requiresCanonicalZeroRendering(module) {\n  return module.functions.some((declaration) => blockContainsSignProducingOperation(declaration.body)) ||\n    blockContainsSignProducingOperation(module.entryPoint.body)\n}\n\n/**\n * Checks one block for sign-producing integer operations.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @returns {boolean} Whether a nested expression can produce signed zero in JavaScript.\n */\nfunction blockContainsSignProducingOperation(block) {\n  return block.statements.some((statement) => {\n    if (statement.kind == \"IfStatement\") {\n      return expressionContainsSignProducingOperation(statement.condition) ||\n        blockContainsSignProducingOperation(statement.consequent) ||\n        Boolean(statement.alternate && blockContainsSignProducingOperation(statement.alternate))\n    }\n    if (statement.kind == \"LocalDeclaration\") return expressionContainsSignProducingOperation(statement.initializer)\n    if (statement.kind == \"AssignmentStatement\" || statement.kind == \"ReturnStatement\" || statement.kind == \"PrintStatement\") {\n      return expressionContainsSignProducingOperation(statement.expression)\n    }\n\n    return false\n  })\n}\n\n/**\n * Checks one expression tree for sign-producing integer operations.\n * @param {import(\"../semantic/types.js\").Expression} expression - Semantic expression.\n * @returns {boolean} Whether this tree contains integer negation or multiplication.\n */\nfunction expressionContainsSignProducingOperation(expression) {\n  if (expression.kind == \"UnaryExpression\") {\n    return expression.operation == \"IntegerNegate\" || expressionContainsSignProducingOperation(expression.operand)\n  }\n  if (expression.kind == \"BinaryExpression\") {\n    return expression.operation == \"IntegerMultiply\" || expressionContainsSignProducingOperation(expression.left) ||\n      expressionContainsSignProducingOperation(expression.right)\n  }\n  if (expression.kind == \"CallExpression\") {\n    return expression.arguments.some((argument) => expressionContainsSignProducingOperation(argument))\n  }\n\n  return false\n}\n\n/**\n * Maps one already validated semantic operation to target syntax.\n * @param {import(\"../semantic/types.js\").SemanticBinaryOperation} operation - Closed semantic operation.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @returns {string} Target operator spelling.\n */\nfunction binaryOperationSpelling(operation, language) {\n  const syntax = binaryOperationSyntax[operation]\n\n  if (language == \"php\" && syntax.php) return syntax.php\n  if ((language == \"php\" || language == \"javascript\" || language == \"typescript\") && syntax.strict) return syntax.strict\n\n  return syntax.default\n}\n"]}

package/build/src/backends/typescript.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emits an independently executable TypeScript program through the source-aware writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export declare function generateTypeScript(module: import("../semantic/types.js").SemanticModule, writer: import("./writer.js").SourceWriter): void;
+//# sourceMappingURL=typescript.d.ts.map

package/build/src/backends/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/backends/typescript.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAJ9B,OAAO,sBAAsB,EAAE,cAID,EAAE,MAAM,EAHtC,OAAO,aAAa,EAAE,YAGgB,GAFpC,IAAI,CA2ChB"}