semantifold 0.1.0

package/build/src/semantic/validate.js

@@ -0,0 +1,472 @@
+// @ts-check
+import { semanticFailure, unsupportedCapability, unsupportedSyntax } from "../diagnostic.js";
+import { hasOnlyUnicodeScalars, isScalarTypeName } from "./scalars.js";
+import { adaptedOperationFor } from "./operators.js";
+/**
+ * @typedef Binding
+ * @property {boolean} mutable - Whether assignment is allowed.
+ * @property {import("./types.js").SemanticTypeName} type - Binding type.
+ */
+/**
+ * @typedef Scope
+ * @property {Map<string, Binding>} bindings - Bindings declared directly in this scope.
+ * @property {Set<string>} pending - Names declared later in this scope.
+ * @property {Scope | undefined} parent - Enclosing lexical scope.
+ * @property {Set<string>} usedNames - All names used by the enclosing function or entry point.
+ */
+/**
+ * @typedef SemanticFail
+ * @type {(code: string, detail: string, location: import("./types.js").SourceLocation) => never}
+ */
+/**
+ * Enforces the coherent release-candidate semantic subset after adaptation.
+ * @param {import("./types.js").SemanticModule} module - Adapted semantic module.
+ * @param {import("./types.js").SemanticLanguage} language - Source language.
+ * @returns {import("./types.js").SemanticModule} Validated module.
+ */
+export function validateParsedModule(module, language) {
+    validateModuleShape(module, (detail, location) => unsupportedSyntax(language, detail, location));
+    validateModuleTypes(module, (code, detail, location) => semanticFailure(language, code, detail, location), true);
+    return module;
+}
+/**
+ * Validates scalar types and bindings for a caller-supplied semantic module before emission.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {import("./types.js").SemanticLanguage} language - Backend language.
+ * @returns {void}
+ */
+export function validateBackendTypes(module, language) {
+    validateModuleTypes(module, (_code, detail, location) => unsupportedCapability(language, detail, location), false);
+}
+/**
+ * Checks parser-authored block and statement layouts before semantic validation.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {(detail: string, location: import("./types.js").SourceLocation) => never} fail - Shape failure.
+ * @returns {void}
+ */
+function validateModuleShape(module, fail) {
+    for (const functionDeclaration of module.functions) {
+        if (functionDeclaration.parameters.length != 2) {
+            fail("function parameter count other than two", functionDeclaration.location);
+        }
+        validateBlockShape(functionDeclaration.body, "function body", fail);
+    }
+    validateBlockShape(module.entryPoint.body, "entry point", fail);
+}
+/**
+ * Checks one recursively nested semantic block produced by a frontend.
+ * @param {import("./types.js").Block} block - Semantic block.
+ * @param {string} detail - Diagnostic detail.
+ * @param {(detail: string, location: import("./types.js").SourceLocation) => never} fail - Shape failure.
+ * @returns {void}
+ */
+function validateBlockShape(block, detail, fail) {
+    if (!block || block.kind != "Block" || !Array.isArray(block.statements)) {
+        fail(`${detail} without Block`, block?.location ?? /** @type {never} */ (undefined));
+    }
+    for (const statement of block.statements) {
+        if (!["AssignmentStatement", "IfStatement", "LocalDeclaration", "PrintStatement", "ReturnStatement"].includes(statement.kind)) {
+            fail(`${detail} statement ${statement.kind}`, statement.location);
+        }
+        if (statement.kind == "IfStatement") {
+            validateBlockShape(statement.consequent, "if consequent", fail);
+            if (statement.alternate)
+                validateBlockShape(statement.alternate, "if alternate", fail);
+        }
+    }
+}
+/**
+ * Validates declarations and expression types within lexical scopes.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @returns {void}
+ */
+function validateModuleTypes(module, fail, normalizeOperations) {
+    /** @type {Map<string, import("./types.js").FunctionDeclaration>} */
+    const functions = new Map();
+    for (const functionDeclaration of module.functions) {
+        if (functions.has(functionDeclaration.name)) {
+            fail("DUPLICATE_BINDING", `duplicate function '${functionDeclaration.name}'.`, functionDeclaration.location);
+        }
+        functions.set(functionDeclaration.name, functionDeclaration);
+    }
+    for (const functionDeclaration of module.functions)
+        validateFunction(functionDeclaration, functions, fail, normalizeOperations);
+    const callableNames = new Set(functions.keys());
+    const entryScope = createScope(undefined, module.entryPoint.body.statements, callableNames);
+    validateBlock(module.entryPoint.body, entryScope, undefined, functions, fail, normalizeOperations);
+}
+/**
+ * Validates one non-void function and its complete control flow.
+ * @param {import("./types.js").FunctionDeclaration} declaration - Function declaration.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Function signatures.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @returns {void}
+ */
+function validateFunction(declaration, functions, fail, normalizeOperations) {
+    const scope = createScope(undefined, declaration.body.statements, new Set(functions.keys()));
+    for (const parameter of declaration.parameters) {
+        const type = validateTypeReference(parameter.type, parameter.location, fail);
+        declareBinding(parameter.name, { mutable: false, type }, parameter.location, scope, fail);
+    }
+    const returnType = validateTypeReference(declaration.returnType, declaration.location, fail);
+    const returns = validateBlock(declaration.body, scope, returnType, functions, fail, normalizeOperations);
+    if (!returns)
+        fail("MISSING_RETURN", `Function '${declaration.name}' does not return on every reachable path.`, declaration.location);
+}
+/**
+ * Validates one ordered block and reports whether every path returns.
+ * @param {import("./types.js").Block} block - Semantic block.
+ * @param {Scope} scope - Scope belonging to this block.
+ * @param {import("./types.js").SemanticTypeName | undefined} returnType - Function return type, absent for entry points.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Function signatures.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @returns {boolean} Whether every path through the block returns.
+ */
+function validateBlock(block, scope, returnType, functions, fail, normalizeOperations) {
+    let alwaysReturns = false;
+    for (const statement of block.statements) {
+        if (alwaysReturns)
+            fail("UNREACHABLE_STATEMENT", "Statement is unreachable.", statement.location);
+        if (statement.kind == "LocalDeclaration") {
+            const declaredType = validateTypeReference(statement.type, statement.location, fail);
+            const initializerType = inferExpressionType(statement.initializer, scope, functions, fail, normalizeOperations);
+            scope.pending.delete(statement.name);
+            if (initializerType != declaredType) {
+                fail("TYPE_MISMATCH", `Initializer type ${initializerType}; expected ${declaredType}.`, statement.initializer.location);
+            }
+            declareBinding(statement.name, { mutable: statement.mutable, type: declaredType }, statement.location, scope, fail);
+            continue;
+        }
+        if (statement.kind == "AssignmentStatement") {
+            const expressionType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
+            const binding = resolveBinding(statement.target.name, statement.target.location, scope, fail);
+            if (!binding.mutable) {
+                fail("IMMUTABLE_ASSIGNMENT", `Cannot assign to immutable binding '${statement.target.name}'.`, statement.target.location);
+            }
+            if (expressionType != binding.type) {
+                fail("TYPE_MISMATCH", `Assignment type ${expressionType}; expected ${binding.type}.`, statement.expression.location);
+            }
+            continue;
+        }
+        if (statement.kind == "PrintStatement") {
+            inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
+            continue;
+        }
+        if (statement.kind == "ReturnStatement") {
+            if (!returnType)
+                fail("ILLEGAL_RETURN_CONTEXT", "Return statement outside a function.", statement.location);
+            const actualType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
+            if (actualType != returnType) {
+                fail("TYPE_MISMATCH", `Return type ${actualType}; expected ${returnType}.`, statement.expression.location);
+            }
+            alwaysReturns = true;
+            continue;
+        }
+        if (statement.kind == "IfStatement") {
+            const conditionType = inferExpressionType(statement.condition, scope, functions, fail, normalizeOperations);
+            if (conditionType != "boolean") {
+                fail("NON_BOOLEAN_CONDITION", `If condition type ${conditionType}; expected boolean.`, statement.condition.location);
+            }
+            const consequentScope = createScope(scope, statement.consequent.statements);
+            const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, fail, normalizeOperations);
+            let alternateReturns = false;
+            if (statement.alternate) {
+                const alternateScope = createScope(scope, statement.alternate.statements);
+                alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, fail, normalizeOperations);
+            }
+            alwaysReturns = consequentReturns && alternateReturns;
+            continue;
+        }
+        const unexpected = /** @type {{kind: string, location: import("./types.js").SourceLocation}} */ (statement);
+        fail("UNSUPPORTED_STATEMENT", unexpected.kind, unexpected.location);
+    }
+    return alwaysReturns;
+}
+/**
+ * Creates a lexical scope with declarations marked pending until visited.
+ * @param {Scope | undefined} parent - Enclosing scope.
+ * @param {{kind: string, name?: string}[]} statements - Scope statements.
+ * @param {Set<string>} [reservedNames] - Names unavailable to root bindings.
+ * @returns {Scope} Scope.
+ */
+function createScope(parent, statements, reservedNames = new Set()) {
+    const pending = new Set(statements.filter((statement) => statement.kind == "LocalDeclaration")
+        .map((statement) => /** @type {{name: string}} */ (statement).name));
+    return { bindings: new Map(), parent, pending, usedNames: parent?.usedNames ?? new Set(reservedNames) };
+}
+/**
+ * Adds one binding while rejecting duplicates and shadowing.
+ * @param {string} name - Binding name.
+ * @param {Binding} binding - Binding metadata.
+ * @param {import("./types.js").SourceLocation} location - Declaration location.
+ * @param {Scope} scope - Current scope.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {void}
+ */
+function declareBinding(name, binding, location, scope, fail) {
+    if (scope.usedNames.has(name))
+        fail("DUPLICATE_BINDING", `Duplicate or shadowed binding '${name}'.`, location);
+    scope.bindings.set(name, binding);
+    scope.usedNames.add(name);
+}
+/**
+ * Resolves one identifier and distinguishes use-before-declaration.
+ * @param {string} name - Binding name.
+ * @param {import("./types.js").SourceLocation} location - Reference location.
+ * @param {Scope} scope - Current scope.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {Binding} Binding.
+ */
+function resolveBinding(name, location, scope, fail) {
+    for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {
+        const binding = current.bindings.get(name);
+        if (binding)
+            return binding;
+        if (current.pending.has(name)) {
+            return fail("USE_BEFORE_DECLARATION", `Binding '${name}' is used before its declaration.`, location);
+        }
+    }
+    return fail("UNRESOLVED_BINDING", `Unknown binding '${name}'.`, location);
+}
+/**
+ * Validates one semantic type reference.
+ * @param {unknown} type - Candidate semantic type reference.
+ * @param {import("./types.js").SourceLocation} location - Owning source location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {import("./types.js").SemanticTypeName} Validated scalar name.
+ */
+function validateTypeReference(type, location, fail) {
+    if (!type || typeof type != "object" || Array.isArray(type)) {
+        return fail("TYPE_MISMATCH", "Unsupported scalar type.", location);
+    }
+    const candidate = /** @type {import("./types.js").TypeReference} */ (type);
+    if (candidate.kind != "TypeReference" || !isScalarTypeName(candidate.name)) {
+        fail("TYPE_MISMATCH", "Unsupported scalar type.", location);
+    }
+    return candidate.name;
+}
+/**
+ * Infers and validates one expression.
+ * @param {import("./types.js").Expression} expression - Semantic expression.
+ * @param {Scope} scope - Visible lexical scope.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @returns {import("./types.js").SemanticTypeName} Expression type.
+ */
+function inferExpressionType(expression, scope, functions, fail, normalizeOperations) {
+    if (expression.kind == "IdentifierExpression")
+        return resolveBinding(expression.name, expression.location, scope, fail).type;
+    if (expression.kind == "IntegerLiteral") {
+        if (!Number.isSafeInteger(expression.value))
+            fail("TYPE_MISMATCH", "Non-safe integer literal.", expression.location);
+        return "integer";
+    }
+    if (expression.kind == "BooleanLiteral") {
+        if (typeof Reflect.get(expression, "value") != "boolean") {
+            fail("TYPE_MISMATCH", "Invalid boolean literal value.", expression.location);
+        }
+        return "boolean";
+    }
+    if (expression.kind == "StringLiteral") {
+        const value = Reflect.get(expression, "value");
+        if (typeof value != "string" || !hasOnlyUnicodeScalars(value)) {
+            fail("TYPE_MISMATCH", "Invalid Unicode string literal.", expression.location);
+        }
+        return "string";
+    }
+    if (expression.kind == "CallExpression") {
+        const functionDeclaration = functions.get(expression.callee);
+        if (!functionDeclaration)
+            return fail("UNRESOLVED_BINDING", `Unknown function '${expression.callee}'.`, expression.location);
+        if (expression.arguments.length != functionDeclaration.parameters.length) {
+            return fail("TYPE_MISMATCH", `Call argument count for '${expression.callee}'.`, expression.location);
+        }
+        for (let index = 0; index < expression.arguments.length; index++) {
+            const argument = expression.arguments[index];
+            const actualType = inferExpressionType(argument, scope, functions, fail, normalizeOperations);
+            const expectedType = validateTypeReference(functionDeclaration.parameters[index].type, functionDeclaration.parameters[index].location, fail);
+            if (actualType != expectedType) {
+                fail("TYPE_MISMATCH", `Call argument type ${actualType}; expected ${expectedType}.`, argument.location);
+            }
+        }
+        return validateTypeReference(functionDeclaration.returnType, functionDeclaration.location, fail);
+    }
+    if (expression.kind == "UnaryExpression") {
+        const operandType = inferExpressionType(expression.operand, scope, functions, fail, normalizeOperations);
+        const operation = normalizeOperations
+            ? normalizeUnaryOperation(adaptedOperationFor(expression), operandType, expression.operand.location, fail)
+            : expression.operation;
+        if (normalizeOperations)
+            setNormalizedOperation(expression, operation, unaryOperationSignatures[operation].result);
+        const signature = unaryOperationSignatures[operation];
+        if (!signature)
+            return fail("TYPE_MISMATCH", `Unknown unary operation ${String(operation)}.`, expression.location);
+        if (operandType != signature.operand) {
+            return fail("INVALID_OPERAND_TYPE", `${operation} requires ${signature.operand}; received ${operandType}.`, expression.operand.location);
+        }
+        if (expression.type != signature.result) {
+            return fail("TYPE_MISMATCH", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location);
+        }
+        return signature.result;
+    }
+    if (expression.kind == "BinaryExpression") {
+        const leftType = inferExpressionType(expression.left, scope, functions, fail, normalizeOperations);
+        const rightType = inferExpressionType(expression.right, scope, functions, fail, normalizeOperations);
+        const operation = normalizeOperations
+            ? normalizeBinaryOperation(adaptedOperationFor(expression), leftType, rightType, expression.left.location, expression.right.location, expression.location, fail)
+            : expression.operation;
+        if (normalizeOperations)
+            setNormalizedOperation(expression, operation, binaryOperationSignatures[operation].result);
+        const signature = binaryOperationSignatures[operation];
+        if (!signature)
+            return fail("TYPE_MISMATCH", `Unknown binary operation ${String(operation)}.`, expression.location);
+        if (leftType != signature.left) {
+            return fail("INVALID_OPERAND_TYPE", `${operation} requires ${signature.left} left operand; received ${leftType}.`, expression.left.location);
+        }
+        if (rightType != signature.right) {
+            return fail("INVALID_OPERAND_TYPE", `${operation} requires ${signature.right} right operand; received ${rightType}.`, expression.right.location);
+        }
+        if (expression.type != signature.result) {
+            return fail("TYPE_MISMATCH", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location);
+        }
+        return signature.result;
+    }
+    const unexpected = /** @type {{kind: string, location: import("./types.js").SourceLocation}} */ (expression);
+    return fail("TYPE_MISMATCH", unexpected.kind, unexpected.location);
+}
+/** @type {Readonly<Record<import("./types.js").SemanticUnaryOperation, {operand: import("./types.js").SemanticTypeName, result: import("./types.js").SemanticTypeName}>>} */
+const unaryOperationSignatures = Object.freeze({
+    BooleanNot: Object.freeze({ operand: "boolean", result: "boolean" }),
+    IntegerNegate: Object.freeze({ operand: "integer", result: "integer" })
+});
+/** @type {Readonly<Record<import("./types.js").SemanticBinaryOperation, {left: import("./types.js").SemanticTypeName, right: import("./types.js").SemanticTypeName, result: import("./types.js").SemanticTypeName}>>} */
+const binaryOperationSignatures = Object.freeze({
+    BooleanAnd: Object.freeze({ left: "boolean", result: "boolean", right: "boolean" }),
+    BooleanEqual: Object.freeze({ left: "boolean", result: "boolean", right: "boolean" }),
+    BooleanNotEqual: Object.freeze({ left: "boolean", result: "boolean", right: "boolean" }),
+    BooleanOr: Object.freeze({ left: "boolean", result: "boolean", right: "boolean" }),
+    IntegerAdd: Object.freeze({ left: "integer", result: "integer", right: "integer" }),
+    IntegerEqual: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerGreaterThan: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerGreaterThanOrEqual: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerLessThan: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerLessThanOrEqual: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerMultiply: Object.freeze({ left: "integer", result: "integer", right: "integer" }),
+    IntegerNotEqual: Object.freeze({ left: "integer", result: "boolean", right: "integer" }),
+    IntegerSubtract: Object.freeze({ left: "integer", result: "integer", right: "integer" }),
+    StringConcat: Object.freeze({ left: "string", result: "string", right: "string" }),
+    StringEqual: Object.freeze({ left: "string", result: "boolean", right: "string" }),
+    StringNotEqual: Object.freeze({ left: "string", result: "boolean", right: "string" })
+});
+/**
+ * Selects one typed unary meaning from parser-normalized source intent.
+ * @param {unknown} sourceOperation - Transient frontend operation.
+ * @param {import("./types.js").SemanticTypeName} operandType - Resolved operand type.
+ * @param {import("./types.js").SourceLocation} location - Operand location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {import("./types.js").SemanticUnaryOperation} Semantic operation.
+ */
+function normalizeUnaryOperation(sourceOperation, operandType, location, fail) {
+    if (sourceOperation == "Negate") {
+        if (operandType != "integer")
+            fail("INVALID_OPERAND_TYPE", `Integer negation requires integer; received ${operandType}.`, location);
+        return "IntegerNegate";
+    }
+    if (sourceOperation == "Not") {
+        if (operandType != "boolean")
+            fail("INVALID_OPERAND_TYPE", `Boolean not requires boolean; received ${operandType}.`, location);
+        return "BooleanNot";
+    }
+    return fail("TYPE_MISMATCH", `Unknown unary source operation ${String(sourceOperation)}.`, location);
+}
+/**
+ * Selects one typed binary meaning from parser-normalized source intent.
+ * @param {unknown} sourceOperation - Transient frontend operation.
+ * @param {import("./types.js").SemanticTypeName} leftType - Resolved left type.
+ * @param {import("./types.js").SemanticTypeName} rightType - Resolved right type.
+ * @param {import("./types.js").SourceLocation} leftLocation - Left operand location.
+ * @param {import("./types.js").SourceLocation} rightLocation - Right operand location.
+ * @param {import("./types.js").SourceLocation} expressionLocation - Whole operation location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {import("./types.js").SemanticBinaryOperation} Semantic operation.
+ */
+function normalizeBinaryOperation(sourceOperation, leftType, rightType, leftLocation, rightLocation, expressionLocation, fail) {
+    if (sourceOperation == "PhpAdd") {
+        if (leftType == "string" && rightType == "string") {
+            return fail("UNSUPPORTED_SYNTAX", "PHP binary + does not concatenate strings; use . instead.", expressionLocation);
+        }
+        sourceOperation = "Add";
+    }
+    if (sourceOperation == "StringConcat") {
+        if (leftType != "string")
+            fail("INVALID_OPERAND_TYPE", `String concatenation requires string; received ${leftType}.`, leftLocation);
+        if (rightType != "string")
+            fail("INVALID_OPERAND_TYPE", `String concatenation requires string; received ${rightType}.`, rightLocation);
+        return "StringConcat";
+    }
+    if (sourceOperation == "Add") {
+        if (leftType == "integer" && rightType == "integer")
+            return "IntegerAdd";
+        if (leftType == "string" && rightType == "string")
+            return "StringConcat";
+        const location = leftType == "integer" || leftType == "string" ? rightLocation : leftLocation;
+        return fail("INVALID_OPERAND_TYPE", `Addition requires two integers or two strings; received ${leftType} and ${rightType}.`, location);
+    }
+    const fixedOperations = /** @type {const} */ ({
+        And: ["boolean", "BooleanAnd"],
+        GreaterThan: ["integer", "IntegerGreaterThan"],
+        GreaterThanOrEqual: ["integer", "IntegerGreaterThanOrEqual"],
+        LessThan: ["integer", "IntegerLessThan"],
+        LessThanOrEqual: ["integer", "IntegerLessThanOrEqual"],
+        Multiply: ["integer", "IntegerMultiply"],
+        Or: ["boolean", "BooleanOr"],
+        Subtract: ["integer", "IntegerSubtract"]
+    });
+    const fixed = Reflect.get(fixedOperations, String(sourceOperation));
+    if (fixed) {
+        const [requiredType, operation] = fixed;
+        if (leftType != requiredType)
+            fail("INVALID_OPERAND_TYPE", `${String(sourceOperation)} requires ${requiredType}; received ${leftType}.`, leftLocation);
+        if (rightType != requiredType)
+            fail("INVALID_OPERAND_TYPE", `${String(sourceOperation)} requires ${requiredType}; received ${rightType}.`, rightLocation);
+        return /** @type {import("./types.js").SemanticBinaryOperation} */ (operation);
+    }
+    if (sourceOperation == "JavaEqual" || sourceOperation == "JavaNotEqual") {
+        if (leftType == "string" || rightType == "string") {
+            return fail("UNSUPPORTED_SYNTAX", "Java reference equality is outside the implemented semantic subset.", expressionLocation);
+        }
+        sourceOperation = sourceOperation == "JavaEqual" ? "Equal" : "NotEqual";
+    }
+    if (sourceOperation == "StringEqual" || sourceOperation == "StringNotEqual") {
+        if (leftType != "string")
+            fail("INVALID_OPERAND_TYPE", `String equality requires string; received ${leftType}.`, leftLocation);
+        if (rightType != "string")
+            fail("INVALID_OPERAND_TYPE", `String equality requires string; received ${rightType}.`, rightLocation);
+        return /** @type {"StringEqual" | "StringNotEqual"} */ (sourceOperation);
+    }
+    if (sourceOperation == "Equal" || sourceOperation == "NotEqual") {
+        if (leftType != rightType) {
+            return fail("MISMATCHED_EQUALITY_TYPES", `Equality requires matching scalar types; received ${leftType} and ${rightType}.`, rightLocation);
+        }
+        const prefix = leftType == "integer" ? "Integer" : leftType == "boolean" ? "Boolean" : "String";
+        return /** @type {import("./types.js").SemanticBinaryOperation} */ (`${prefix}${sourceOperation}`);
+    }
+    return fail("TYPE_MISMATCH", `Unknown binary source operation ${String(sourceOperation)}.`, leftLocation);
+}
+/**
+ * Replaces transient frontend intent with the public typed operation fields.
+ * @param {object} expression - Mutable adapted expression.
+ * @param {import("./types.js").SemanticUnaryOperation | import("./types.js").SemanticBinaryOperation} operation - Typed operation.
+ * @param {import("./types.js").SemanticTypeName} type - Explicit result type.
+ * @returns {void}
+ */
+function setNormalizedOperation(expression, operation, type) {
+    Reflect.set(expression, "operation", operation);
+    Reflect.set(expression, "type", type);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../src/semantic/validate.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {semanticFailure, unsupportedCapability, unsupportedSyntax} from \"../diagnostic.js\"\nimport {hasOnlyUnicodeScalars, isScalarTypeName} from \"./scalars.js\"\nimport {adaptedOperationFor} from \"./operators.js\"\n\n/**\n * @typedef Binding\n * @property {boolean} mutable - Whether assignment is allowed.\n * @property {import(\"./types.js\").SemanticTypeName} type - Binding type.\n */\n\n/**\n * @typedef Scope\n * @property {Map<string, Binding>} bindings - Bindings declared directly in this scope.\n * @property {Set<string>} pending - Names declared later in this scope.\n * @property {Scope | undefined} parent - Enclosing lexical scope.\n * @property {Set<string>} usedNames - All names used by the enclosing function or entry point.\n */\n\n/**\n * @typedef SemanticFail\n * @type {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never}\n */\n\n/**\n * Enforces the coherent release-candidate semantic subset after adaptation.\n * @param {import(\"./types.js\").SemanticModule} module - Adapted semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Source language.\n * @returns {import(\"./types.js\").SemanticModule} Validated module.\n */\nexport function validateParsedModule(module, language) {\n  validateModuleShape(module, (detail, location) => unsupportedSyntax(language, detail, location))\n  validateModuleTypes(module, (code, detail, location) => semanticFailure(language, code, detail, location), true)\n\n  return module\n}\n\n/**\n * Validates scalar types and bindings for a caller-supplied semantic module before emission.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Backend language.\n * @returns {void}\n */\nexport function validateBackendTypes(module, language) {\n  validateModuleTypes(module, (_code, detail, location) => unsupportedCapability(language, detail, location), false)\n}\n\n/**\n * Checks parser-authored block and statement layouts before semantic validation.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateModuleShape(module, fail) {\n  for (const functionDeclaration of module.functions) {\n    if (functionDeclaration.parameters.length != 2) {\n      fail(\"function parameter count other than two\", functionDeclaration.location)\n    }\n\n    validateBlockShape(functionDeclaration.body, \"function body\", fail)\n  }\n\n  validateBlockShape(module.entryPoint.body, \"entry point\", fail)\n}\n\n/**\n * Checks one recursively nested semantic block produced by a frontend.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {string} detail - Diagnostic detail.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateBlockShape(block, detail, fail) {\n  if (!block || block.kind != \"Block\" || !Array.isArray(block.statements)) {\n    fail(`${detail} without Block`, block?.location ?? /** @type {never} */ (undefined))\n  }\n\n  for (const statement of block.statements) {\n    if (![\"AssignmentStatement\", \"IfStatement\", \"LocalDeclaration\", \"PrintStatement\", \"ReturnStatement\"].includes(statement.kind)) {\n      fail(`${detail} statement ${statement.kind}`, statement.location)\n    }\n    if (statement.kind == \"IfStatement\") {\n      validateBlockShape(statement.consequent, \"if consequent\", fail)\n      if (statement.alternate) validateBlockShape(statement.alternate, \"if alternate\", fail)\n    }\n  }\n}\n\n/**\n * Validates declarations and expression types within lexical scopes.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {void}\n */\nfunction validateModuleTypes(module, fail, normalizeOperations) {\n  /** @type {Map<string, import(\"./types.js\").FunctionDeclaration>} */\n  const functions = new Map()\n\n  for (const functionDeclaration of module.functions) {\n    if (functions.has(functionDeclaration.name)) {\n      fail(\"DUPLICATE_BINDING\", `duplicate function '${functionDeclaration.name}'.`, functionDeclaration.location)\n    }\n    functions.set(functionDeclaration.name, functionDeclaration)\n  }\n\n  for (const functionDeclaration of module.functions) validateFunction(functionDeclaration, functions, fail, normalizeOperations)\n\n  const callableNames = new Set(functions.keys())\n\n  const entryScope = createScope(undefined, module.entryPoint.body.statements, callableNames)\n\n  validateBlock(module.entryPoint.body, entryScope, undefined, functions, fail, normalizeOperations)\n}\n\n/**\n * Validates one non-void function and its complete control flow.\n * @param {import(\"./types.js\").FunctionDeclaration} declaration - Function declaration.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {void}\n */\nfunction validateFunction(declaration, functions, fail, normalizeOperations) {\n  const scope = createScope(undefined, declaration.body.statements, new Set(functions.keys()))\n\n  for (const parameter of declaration.parameters) {\n    const type = validateTypeReference(parameter.type, parameter.location, fail)\n\n    declareBinding(parameter.name, {mutable: false, type}, parameter.location, scope, fail)\n  }\n\n  const returnType = validateTypeReference(declaration.returnType, declaration.location, fail)\n  const returns = validateBlock(declaration.body, scope, returnType, functions, fail, normalizeOperations)\n\n  if (!returns) fail(\"MISSING_RETURN\", `Function '${declaration.name}' does not return on every reachable path.`, declaration.location)\n}\n\n/**\n * Validates one ordered block and reports whether every path returns.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {Scope} scope - Scope belonging to this block.\n * @param {import(\"./types.js\").SemanticTypeName | undefined} returnType - Function return type, absent for entry points.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {boolean} Whether every path through the block returns.\n */\nfunction validateBlock(block, scope, returnType, functions, fail, normalizeOperations) {\n  let alwaysReturns = false\n\n  for (const statement of block.statements) {\n    if (alwaysReturns) fail(\"UNREACHABLE_STATEMENT\", \"Statement is unreachable.\", statement.location)\n\n    if (statement.kind == \"LocalDeclaration\") {\n      const declaredType = validateTypeReference(statement.type, statement.location, fail)\n      const initializerType = inferExpressionType(statement.initializer, scope, functions, fail, normalizeOperations)\n\n      scope.pending.delete(statement.name)\n      if (initializerType != declaredType) {\n        fail(\"TYPE_MISMATCH\", `Initializer type ${initializerType}; expected ${declaredType}.`, statement.initializer.location)\n      }\n      declareBinding(statement.name, {mutable: statement.mutable, type: declaredType}, statement.location, scope, fail)\n      continue\n    }\n    if (statement.kind == \"AssignmentStatement\") {\n      const expressionType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n      const binding = resolveBinding(statement.target.name, statement.target.location, scope, fail)\n\n      if (!binding.mutable) {\n        fail(\"IMMUTABLE_ASSIGNMENT\", `Cannot assign to immutable binding '${statement.target.name}'.`, statement.target.location)\n      }\n      if (expressionType != binding.type) {\n        fail(\"TYPE_MISMATCH\", `Assignment type ${expressionType}; expected ${binding.type}.`, statement.expression.location)\n      }\n      continue\n    }\n    if (statement.kind == \"PrintStatement\") {\n      inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n      continue\n    }\n    if (statement.kind == \"ReturnStatement\") {\n      if (!returnType) fail(\"ILLEGAL_RETURN_CONTEXT\", \"Return statement outside a function.\", statement.location)\n      const actualType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n\n      if (actualType != returnType) {\n        fail(\"TYPE_MISMATCH\", `Return type ${actualType}; expected ${returnType}.`, statement.expression.location)\n      }\n      alwaysReturns = true\n      continue\n    }\n    if (statement.kind == \"IfStatement\") {\n      const conditionType = inferExpressionType(statement.condition, scope, functions, fail, normalizeOperations)\n\n      if (conditionType != \"boolean\") {\n        fail(\"NON_BOOLEAN_CONDITION\", `If condition type ${conditionType}; expected boolean.`, statement.condition.location)\n      }\n      const consequentScope = createScope(scope, statement.consequent.statements)\n      const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, fail, normalizeOperations)\n      let alternateReturns = false\n\n      if (statement.alternate) {\n        const alternateScope = createScope(scope, statement.alternate.statements)\n\n        alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, fail, normalizeOperations)\n      }\n      alwaysReturns = consequentReturns && alternateReturns\n      continue\n    }\n\n    const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (statement)\n\n    fail(\"UNSUPPORTED_STATEMENT\", unexpected.kind, unexpected.location)\n  }\n\n  return alwaysReturns\n}\n\n/**\n * Creates a lexical scope with declarations marked pending until visited.\n * @param {Scope | undefined} parent - Enclosing scope.\n * @param {{kind: string, name?: string}[]} statements - Scope statements.\n * @param {Set<string>} [reservedNames] - Names unavailable to root bindings.\n * @returns {Scope} Scope.\n */\nfunction createScope(parent, statements, reservedNames = new Set()) {\n  const pending = new Set(statements.filter((statement) => statement.kind == \"LocalDeclaration\")\n    .map((statement) => /** @type {{name: string}} */ (statement).name))\n\n  return {bindings: new Map(), parent, pending, usedNames: parent?.usedNames ?? new Set(reservedNames)}\n}\n\n/**\n * Adds one binding while rejecting duplicates and shadowing.\n * @param {string} name - Binding name.\n * @param {Binding} binding - Binding metadata.\n * @param {import(\"./types.js\").SourceLocation} location - Declaration location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction declareBinding(name, binding, location, scope, fail) {\n  if (scope.usedNames.has(name)) fail(\"DUPLICATE_BINDING\", `Duplicate or shadowed binding '${name}'.`, location)\n\n  scope.bindings.set(name, binding)\n  scope.usedNames.add(name)\n}\n\n/**\n * Resolves one identifier and distinguishes use-before-declaration.\n * @param {string} name - Binding name.\n * @param {import(\"./types.js\").SourceLocation} location - Reference location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {Binding} Binding.\n */\nfunction resolveBinding(name, location, scope, fail) {\n  for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {\n    const binding = current.bindings.get(name)\n\n    if (binding) return binding\n    if (current.pending.has(name)) {\n      return fail(\"USE_BEFORE_DECLARATION\", `Binding '${name}' is used before its declaration.`, location)\n    }\n  }\n\n  return fail(\"UNRESOLVED_BINDING\", `Unknown binding '${name}'.`, location)\n}\n\n/**\n * Validates one semantic type reference.\n * @param {unknown} type - Candidate semantic type reference.\n * @param {import(\"./types.js\").SourceLocation} location - Owning source location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticTypeName} Validated scalar name.\n */\nfunction validateTypeReference(type, location, fail) {\n  if (!type || typeof type != \"object\" || Array.isArray(type)) {\n    return fail(\"TYPE_MISMATCH\", \"Unsupported scalar type.\", location)\n  }\n\n  const candidate = /** @type {import(\"./types.js\").TypeReference} */ (type)\n\n  if (candidate.kind != \"TypeReference\" || !isScalarTypeName(candidate.name)) {\n    fail(\"TYPE_MISMATCH\", \"Unsupported scalar type.\", location)\n  }\n\n  return candidate.name\n}\n\n/**\n * Infers and validates one expression.\n * @param {import(\"./types.js\").Expression} expression - Semantic expression.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {import(\"./types.js\").SemanticTypeName} Expression type.\n */\nfunction inferExpressionType(expression, scope, functions, fail, normalizeOperations) {\n  if (expression.kind == \"IdentifierExpression\") return resolveBinding(expression.name, expression.location, scope, fail).type\n\n  if (expression.kind == \"IntegerLiteral\") {\n    if (!Number.isSafeInteger(expression.value)) fail(\"TYPE_MISMATCH\", \"Non-safe integer literal.\", expression.location)\n    return \"integer\"\n  }\n  if (expression.kind == \"BooleanLiteral\") {\n    if (typeof Reflect.get(expression, \"value\") != \"boolean\") {\n      fail(\"TYPE_MISMATCH\", \"Invalid boolean literal value.\", expression.location)\n    }\n    return \"boolean\"\n  }\n  if (expression.kind == \"StringLiteral\") {\n    const value = Reflect.get(expression, \"value\")\n\n    if (typeof value != \"string\" || !hasOnlyUnicodeScalars(value)) {\n      fail(\"TYPE_MISMATCH\", \"Invalid Unicode string literal.\", expression.location)\n    }\n    return \"string\"\n  }\n  if (expression.kind == \"CallExpression\") {\n    const functionDeclaration = functions.get(expression.callee)\n\n    if (!functionDeclaration) return fail(\"UNRESOLVED_BINDING\", `Unknown function '${expression.callee}'.`, expression.location)\n    if (expression.arguments.length != functionDeclaration.parameters.length) {\n      return fail(\"TYPE_MISMATCH\", `Call argument count for '${expression.callee}'.`, expression.location)\n    }\n    for (let index = 0; index < expression.arguments.length; index++) {\n      const argument = expression.arguments[index]\n      const actualType = inferExpressionType(argument, scope, functions, fail, normalizeOperations)\n      const expectedType = validateTypeReference(functionDeclaration.parameters[index].type, functionDeclaration.parameters[index].location, fail)\n\n      if (actualType != expectedType) {\n        fail(\"TYPE_MISMATCH\", `Call argument type ${actualType}; expected ${expectedType}.`, argument.location)\n      }\n    }\n    return validateTypeReference(functionDeclaration.returnType, functionDeclaration.location, fail)\n  }\n  if (expression.kind == \"UnaryExpression\") {\n    const operandType = inferExpressionType(expression.operand, scope, functions, fail, normalizeOperations)\n    const operation = normalizeOperations\n      ? normalizeUnaryOperation(adaptedOperationFor(expression), operandType, expression.operand.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, unaryOperationSignatures[operation].result)\n\n    const signature = unaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown unary operation ${String(operation)}.`, expression.location)\n    if (operandType != signature.operand) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.operand}; received ${operandType}.`, expression.operand.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return signature.result\n  }\n  if (expression.kind == \"BinaryExpression\") {\n    const leftType = inferExpressionType(expression.left, scope, functions, fail, normalizeOperations)\n    const rightType = inferExpressionType(expression.right, scope, functions, fail, normalizeOperations)\n    const operation = normalizeOperations\n      ? normalizeBinaryOperation(adaptedOperationFor(expression), leftType, rightType, expression.left.location, expression.right.location, expression.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, binaryOperationSignatures[operation].result)\n\n    const signature = binaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown binary operation ${String(operation)}.`, expression.location)\n    if (leftType != signature.left) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.left} left operand; received ${leftType}.`, expression.left.location)\n    }\n    if (rightType != signature.right) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.right} right operand; received ${rightType}.`, expression.right.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return signature.result\n  }\n\n  const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (expression)\n\n  return fail(\"TYPE_MISMATCH\", unexpected.kind, unexpected.location)\n}\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticUnaryOperation, {operand: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst unaryOperationSignatures = Object.freeze({\n  BooleanNot: Object.freeze({operand: \"boolean\", result: \"boolean\"}),\n  IntegerNegate: Object.freeze({operand: \"integer\", result: \"integer\"})\n})\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticBinaryOperation, {left: import(\"./types.js\").SemanticTypeName, right: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst binaryOperationSignatures = Object.freeze({\n  BooleanAnd: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanNotEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanOr: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  IntegerAdd: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerMultiply: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerNotEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerSubtract: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  StringConcat: Object.freeze({left: \"string\", result: \"string\", right: \"string\"}),\n  StringEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"}),\n  StringNotEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"})\n})\n\n/**\n * Selects one typed unary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} operandType - Resolved operand type.\n * @param {import(\"./types.js\").SourceLocation} location - Operand location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticUnaryOperation} Semantic operation.\n */\nfunction normalizeUnaryOperation(sourceOperation, operandType, location, fail) {\n  if (sourceOperation == \"Negate\") {\n    if (operandType != \"integer\") fail(\"INVALID_OPERAND_TYPE\", `Integer negation requires integer; received ${operandType}.`, location)\n    return \"IntegerNegate\"\n  }\n  if (sourceOperation == \"Not\") {\n    if (operandType != \"boolean\") fail(\"INVALID_OPERAND_TYPE\", `Boolean not requires boolean; received ${operandType}.`, location)\n    return \"BooleanNot\"\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown unary source operation ${String(sourceOperation)}.`, location)\n}\n\n/**\n * Selects one typed binary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} leftType - Resolved left type.\n * @param {import(\"./types.js\").SemanticTypeName} rightType - Resolved right type.\n * @param {import(\"./types.js\").SourceLocation} leftLocation - Left operand location.\n * @param {import(\"./types.js\").SourceLocation} rightLocation - Right operand location.\n * @param {import(\"./types.js\").SourceLocation} expressionLocation - Whole operation location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticBinaryOperation} Semantic operation.\n */\nfunction normalizeBinaryOperation(sourceOperation, leftType, rightType, leftLocation, rightLocation, expressionLocation, fail) {\n  if (sourceOperation == \"PhpAdd\") {\n    if (leftType == \"string\" && rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"PHP binary + does not concatenate strings; use . instead.\", expressionLocation)\n    }\n\n    sourceOperation = \"Add\"\n  }\n\n  if (sourceOperation == \"StringConcat\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${rightType}.`, rightLocation)\n    return \"StringConcat\"\n  }\n\n  if (sourceOperation == \"Add\") {\n    if (leftType == \"integer\" && rightType == \"integer\") return \"IntegerAdd\"\n    if (leftType == \"string\" && rightType == \"string\") return \"StringConcat\"\n\n    const location = leftType == \"integer\" || leftType == \"string\" ? rightLocation : leftLocation\n\n    return fail(\"INVALID_OPERAND_TYPE\", `Addition requires two integers or two strings; received ${leftType} and ${rightType}.`, location)\n  }\n\n  const fixedOperations = /** @type {const} */ ({\n    And: [\"boolean\", \"BooleanAnd\"],\n    GreaterThan: [\"integer\", \"IntegerGreaterThan\"],\n    GreaterThanOrEqual: [\"integer\", \"IntegerGreaterThanOrEqual\"],\n    LessThan: [\"integer\", \"IntegerLessThan\"],\n    LessThanOrEqual: [\"integer\", \"IntegerLessThanOrEqual\"],\n    Multiply: [\"integer\", \"IntegerMultiply\"],\n    Or: [\"boolean\", \"BooleanOr\"],\n    Subtract: [\"integer\", \"IntegerSubtract\"]\n  })\n  const fixed = Reflect.get(fixedOperations, String(sourceOperation))\n\n  if (fixed) {\n    const [requiredType, operation] = fixed\n\n    if (leftType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${leftType}.`, leftLocation)\n    if (rightType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${rightType}.`, rightLocation)\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (operation)\n  }\n\n  if (sourceOperation == \"JavaEqual\" || sourceOperation == \"JavaNotEqual\") {\n    if (leftType == \"string\" || rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"Java reference equality is outside the implemented semantic subset.\", expressionLocation)\n    }\n\n    sourceOperation = sourceOperation == \"JavaEqual\" ? \"Equal\" : \"NotEqual\"\n  }\n\n  if (sourceOperation == \"StringEqual\" || sourceOperation == \"StringNotEqual\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${rightType}.`, rightLocation)\n\n    return /** @type {\"StringEqual\" | \"StringNotEqual\"} */ (sourceOperation)\n  }\n\n  if (sourceOperation == \"Equal\" || sourceOperation == \"NotEqual\") {\n    if (leftType != rightType) {\n      return fail(\"MISMATCHED_EQUALITY_TYPES\", `Equality requires matching scalar types; received ${leftType} and ${rightType}.`, rightLocation)\n    }\n\n    const prefix = leftType == \"integer\" ? \"Integer\" : leftType == \"boolean\" ? \"Boolean\" : \"String\"\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (`${prefix}${sourceOperation}`)\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown binary source operation ${String(sourceOperation)}.`, leftLocation)\n}\n\n/**\n * Replaces transient frontend intent with the public typed operation fields.\n * @param {object} expression - Mutable adapted expression.\n * @param {import(\"./types.js\").SemanticUnaryOperation | import(\"./types.js\").SemanticBinaryOperation} operation - Typed operation.\n * @param {import(\"./types.js\").SemanticTypeName} type - Explicit result type.\n * @returns {void}\n */\nfunction setNormalizedOperation(expression, operation, type) {\n  Reflect.set(expression, \"operation\", operation)\n  Reflect.set(expression, \"type\", type)\n}\n"]}