@tsonic/frontend 0.0.73 → 0.0.75

package/dist/ir/validation/numeric-classification.js

@@ -0,0 +1,368 @@
+/**
+ * Numeric Classification - Expression classification and type helpers
+ *
+ * This sub-module provides:
+ * - classifyNumericExpr: Classify an expression's numeric kind
+ * - hasExplicitDoubleIntent: Check if an expression has explicit double intent
+ * - getExpectedNumericKind: Get the expected numeric kind from a type
+ * - tryGetObjectPropertyType: Extract expected type of a property from structural type
+ * - tryGetTupleElementType: Extract expected type of a tuple element
+ * - needsCoercion: Check if an expression needs coercion to match expected type
+ * - describeExpression: Get human-readable description of an expression
+ * - moduleLocation: Create a source location for a module
+ *
+ * Split from numeric-coercion-pass.ts for file-size management.
+ */
+import { getBinaryResultKind, } from "../types.js";
+import { isWideningConversion, TSONIC_TO_NUMERIC_KIND, literalFitsInKind, } from "../types/numeric-kind.js";
+/**
+ * Maximum absolute value for a 32-bit float (Single).
+ * Used for validating literal narrowing to float.
+ */
+const MAX_FLOAT_ABS = 3.4028235e38;
+/**
+ * Arithmetic operators that produce numeric results.
+ * Used to classify binary expression results.
+ */
+const ARITHMETIC_OPERATORS = new Set(["+", "-", "*", "/", "%"]);
+/**
+ * Classify an expression's numeric kind.
+ *
+ * This function propagates numeric kind through:
+ * - Literals (via numericIntent)
+ * - Identifiers with primitiveType(name="int") or primitiveType(name="number")
+ * - Arithmetic operations (uses C# promotion rules)
+ * - Unary +/- (preserves operand kind)
+ * - Ternary (requires both branches to have same kind)
+ * - Parentheses (pass through)
+ * - numericNarrowing expressions (uses targetKind)
+ *
+ * Returns "Unknown" for expressions that cannot be classified.
+ */
+export const classifyNumericExpr = (expr) => {
+    switch (expr.kind) {
+        case "literal": {
+            // Check numericIntent on literal expressions
+            if (typeof expr.value === "number" && expr.numericIntent) {
+                return expr.numericIntent === "Int32" ? "Int32" : "Double";
+            }
+            // Non-numeric literals
+            return "Unknown";
+        }
+        case "identifier": {
+            // Check inferredType on identifiers
+            if (expr.inferredType?.kind === "primitiveType") {
+                if (expr.inferredType.name === "int")
+                    return "Int32";
+                if (expr.inferredType.name === "number")
+                    return "Double";
+            }
+            // Also check for CLR numeric reference types
+            if (expr.inferredType?.kind === "referenceType") {
+                const name = expr.inferredType.name;
+                if (name === "Int32" || name === "int")
+                    return "Int32";
+                if (name === "Double" || name === "double")
+                    return "Double";
+            }
+            return "Unknown";
+        }
+        case "unary": {
+            // Unary +/- preserves operand kind
+            if (expr.operator === "+" || expr.operator === "-") {
+                return classifyNumericExpr(expr.expression);
+            }
+            // Bitwise NOT (~) produces Int32
+            if (expr.operator === "~") {
+                return "Int32";
+            }
+            return "Unknown";
+        }
+        case "binary": {
+            // Only classify arithmetic operators
+            if (!ARITHMETIC_OPERATORS.has(expr.operator)) {
+                return "Unknown";
+            }
+            const leftKind = classifyNumericExpr(expr.left);
+            const rightKind = classifyNumericExpr(expr.right);
+            // If either is Unknown, we can't classify
+            if (leftKind === "Unknown" || rightKind === "Unknown") {
+                return "Unknown";
+            }
+            // Use C# binary promotion rules
+            // Note: getBinaryResultKind returns NumericKind, we map to our simplified type
+            const resultKind = getBinaryResultKind(leftKind === "Int32" ? "Int32" : "Double", rightKind === "Int32" ? "Int32" : "Double");
+            // Map back to our simplified kind
+            if (resultKind === "Double" || resultKind === "Single")
+                return "Double";
+            return "Int32"; // All integer promotions end up as at least Int32
+        }
+        case "conditional": {
+            // Ternary: both branches must have same kind
+            const trueKind = classifyNumericExpr(expr.whenTrue);
+            const falseKind = classifyNumericExpr(expr.whenFalse);
+            if (trueKind === falseKind)
+                return trueKind;
+            // Mismatched branches - use promotion
+            if (trueKind === "Double" || falseKind === "Double")
+                return "Double";
+            return "Unknown";
+        }
+        case "numericNarrowing": {
+            // numericNarrowing has explicit targetKind
+            if (expr.targetKind === "Int32")
+                return "Int32";
+            if (expr.targetKind === "Double")
+                return "Double";
+            // Other numeric kinds (Byte, Int64, etc.) - treat as Unknown for this pass
+            return "Unknown";
+        }
+        case "call": {
+            // Check return type
+            if (expr.inferredType?.kind === "primitiveType") {
+                if (expr.inferredType.name === "int")
+                    return "Int32";
+                if (expr.inferredType.name === "number")
+                    return "Double";
+            }
+            return "Unknown";
+        }
+        case "memberAccess": {
+            // Check inferredType for member access results
+            if (expr.inferredType?.kind === "primitiveType") {
+                if (expr.inferredType.name === "int")
+                    return "Int32";
+                if (expr.inferredType.name === "number")
+                    return "Double";
+            }
+            return "Unknown";
+        }
+        case "update": {
+            // ++/-- on int produces int
+            const operandKind = classifyNumericExpr(expr.expression);
+            return operandKind;
+        }
+        default:
+            return "Unknown";
+    }
+};
+/**
+ * Check if an expression has explicit double intent.
+ * This is true when:
+ * - It's a numericNarrowing with targetKind "Double" (i.e., `42 as number`)
+ * - It's a literal with numericIntent "Double" (i.e., `42.0`)
+ *
+ * Used to exempt explicit casts from TSN5110 errors.
+ */
+export const hasExplicitDoubleIntent = (expr) => {
+    // Case 1: numericNarrowing targeting Double (e.g., `42 as number`, `42 as double`)
+    if (expr.kind === "numericNarrowing" && expr.targetKind === "Double") {
+        return true;
+    }
+    // Case 2: Literal with double lexeme (e.g., `42.0`)
+    if (expr.kind === "literal" &&
+        typeof expr.value === "number" &&
+        expr.numericIntent === "Double") {
+        return true;
+    }
+    return false;
+};
+/**
+ * Create a source location for a module
+ */
+export const moduleLocation = (ctx) => ({
+    file: ctx.filePath,
+    line: 1,
+    column: 1,
+    length: 1,
+});
+/**
+ * Get the expected numeric kind from a type.
+ * Returns undefined if the type is not a numeric type.
+ *
+ * Maps:
+ * - primitiveType("number") → "Double"
+ * - primitiveType("int") → "Int32"
+ * - referenceType with name in TSONIC_TO_NUMERIC_KIND → corresponding kind
+ */
+export const getExpectedNumericKind = (type) => {
+    if (!type)
+        return undefined;
+    // Strip nullish wrapper if present (T | null | undefined → T)
+    const baseType = type.kind === "unionType"
+        ? type.types.find((t) => !(t.kind === "primitiveType" &&
+            (t.name === "null" || t.name === "undefined")))
+        : type;
+    if (!baseType)
+        return undefined;
+    // primitiveType mapping
+    if (baseType.kind === "primitiveType") {
+        if (baseType.name === "number")
+            return "Double";
+        if (baseType.name === "int")
+            return "Int32";
+        // Check if it's a known numeric type alias
+        const kind = TSONIC_TO_NUMERIC_KIND.get(baseType.name);
+        if (kind)
+            return kind;
+    }
+    // referenceType mapping (CLR types like Int32, Double, etc.)
+    if (baseType.kind === "referenceType") {
+        const name = baseType.name;
+        // Direct CLR type names
+        if (name === "Int32" || name === "int")
+            return "Int32";
+        if (name === "Double" || name === "double")
+            return "Double";
+        if (name === "Int64" || name === "long")
+            return "Int64";
+        if (name === "Single" || name === "float")
+            return "Single";
+        // Check the mapping table
+        const kind = TSONIC_TO_NUMERIC_KIND.get(name.toLowerCase());
+        if (kind)
+            return kind;
+    }
+    return undefined;
+};
+/**
+ * Extract the expected type of a property from a structural type.
+ *
+ * Used for validating object literal properties against their expected types.
+ * Returns undefined if the property type cannot be determined (conservative).
+ *
+ * Handles:
+ * - objectType: inline object types like `{ x: number }`
+ * - referenceType with structuralMembers: interfaces and type aliases
+ */
+export const tryGetObjectPropertyType = (expectedType, propName) => {
+    if (!expectedType)
+        return undefined;
+    // Structural object type: objectType has members directly
+    if (expectedType.kind === "objectType") {
+        const member = expectedType.members.find((m) => m.kind === "propertySignature" && m.name === propName);
+        return member?.type;
+    }
+    // Reference type with structural members (interfaces, type aliases)
+    if (expectedType.kind === "referenceType" && expectedType.structuralMembers) {
+        const member = expectedType.structuralMembers.find((m) => m.kind === "propertySignature" && m.name === propName);
+        return member?.type;
+    }
+    return undefined;
+};
+/**
+ * Extract the expected type of a tuple element at a given index.
+ *
+ * Used for validating tuple literal elements against their expected types.
+ * Returns undefined if the element type cannot be determined.
+ */
+export const tryGetTupleElementType = (expectedType, index) => {
+    if (!expectedType)
+        return undefined;
+    if (expectedType.kind === "tupleType") {
+        return expectedType.elementTypes[index];
+    }
+    return undefined;
+};
+/**
+ * Check if an expression needs coercion to match an expected numeric type.
+ *
+ * Returns true (error) only for NARROWING conversions.
+ * Widening conversions (e.g., Int32 → Double) are implicitly allowed.
+ *
+ * Rules:
+ * - Same kind → OK
+ * - Widening (isWideningConversion returns true) → OK
+ * - Narrowing → requires explicit intent (numericNarrowing node)
+ */
+export const needsCoercion = (expr, expectedType) => {
+    // Get numeric kinds
+    const expectedKind = getExpectedNumericKind(expectedType);
+    const actualKind = classifyNumericExpr(expr);
+    // If either is not a numeric type, no coercion check needed
+    if (expectedKind === undefined || actualKind === "Unknown") {
+        return false;
+    }
+    // Map actualKind to NumericKind (classifyNumericExpr returns "Int32" | "Double" | "Unknown")
+    const actualNumericKind = actualKind === "Int32" ? "Int32" : "Double";
+    // Same kind → OK
+    if (actualNumericKind === expectedKind) {
+        return false;
+    }
+    // Widening conversion → OK (e.g., Int32 → Double)
+    if (isWideningConversion(actualNumericKind, expectedKind)) {
+        return false;
+    }
+    // Narrowing conversion → check for explicit intent
+    // numericNarrowing expressions represent explicit user intent (e.g., `x as int`)
+    if (expr.kind === "numericNarrowing") {
+        return false;
+    }
+    // Allow constant-literal narrowing when the literal fits the target type.
+    // This mirrors C#'s constant expression conversion rules and is ONLY allowed for literals.
+    const allowConstantLiteralNarrowing = (v) => {
+        // Integer target kinds: require safe integer, integral value, and in-range.
+        if (expectedKind === "SByte" ||
+            expectedKind === "Byte" ||
+            expectedKind === "Int16" ||
+            expectedKind === "UInt16" ||
+            expectedKind === "UInt32" ||
+            expectedKind === "UInt64" ||
+            expectedKind === "Int64") {
+            if (Number.isSafeInteger(v) &&
+                Number.isInteger(v) &&
+                literalFitsInKind(v, expectedKind)) {
+                return true;
+            }
+        }
+        // Float target kind: allow finite values in float range.
+        if (expectedKind === "Single") {
+            if (Number.isFinite(v) && Math.abs(v) <= MAX_FLOAT_ABS) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (expr.kind === "literal" && typeof expr.value === "number") {
+        if (allowConstantLiteralNarrowing(expr.value)) {
+            return false;
+        }
+    }
+    if (expr.kind === "unary" &&
+        (expr.operator === "+" || expr.operator === "-") &&
+        expr.expression.kind === "literal" &&
+        typeof expr.expression.value === "number") {
+        const signedValue = expr.operator === "-" ? -expr.expression.value : expr.expression.value;
+        if (allowConstantLiteralNarrowing(signedValue)) {
+            return false;
+        }
+    }
+    // Narrowing without explicit intent → error
+    return true;
+};
+/**
+ * Get a human-readable description of an expression for error messages.
+ */
+export const describeExpression = (expr) => {
+    switch (expr.kind) {
+        case "literal":
+            return `literal '${expr.raw ?? String(expr.value)}'`;
+        case "identifier":
+            return `identifier '${expr.name}'`;
+        case "binary":
+            return `arithmetic expression`;
+        case "unary":
+            return `unary expression`;
+        case "conditional":
+            return `ternary expression`;
+        case "call":
+            return `call result`;
+        case "memberAccess":
+            return typeof expr.property === "string"
+                ? `property '${expr.property}'`
+                : `computed property`;
+        default:
+            return `expression`;
+    }
+};
+//# sourceMappingURL=numeric-classification.js.map

package/dist/ir/validation/numeric-classification.js.map

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

package/dist/ir/validation/numeric-coercion-pass.d.ts

@@ -28,56 +28,9 @@
  *
  * This pass runs AFTER the IR is built, BEFORE emission.
  * It is a HARD GATE - any errors prevent emission.
- */
-import { Diagnostic } from "../../types/diagnostic.js";
-import { IrModule, IrExpression } from "../types.js";
-/**
- * Result of numeric expression classification.
- * - "Int32": Expression definitely produces an Int32 value
- * - "Double": Expression definitely produces a Double value
- * - "Unknown": Cannot determine at compile time (e.g., untyped identifier, complex call)
- */
-export type NumericExprKind = "Int32" | "Double" | "Unknown";
-/**
- * Classify an expression's numeric kind.
- *
- * This function propagates numeric kind through:
- * - Literals (via numericIntent)
- * - Identifiers with primitiveType(name="int") or primitiveType(name="number")
- * - Arithmetic operations (uses C# promotion rules)
- * - Unary +/- (preserves operand kind)
- * - Ternary (requires both branches to have same kind)
- * - Parentheses (pass through)
- * - numericNarrowing expressions (uses targetKind)
- *
- * Returns "Unknown" for expressions that cannot be classified.
- */
-export declare const classifyNumericExpr: (expr: IrExpression) => NumericExprKind;
-/**
- * Check if an expression has explicit double intent.
- * This is true when:
- * - It's a numericNarrowing with targetKind "Double" (i.e., `42 as number`)
- * - It's a literal with numericIntent "Double" (i.e., `42.0`)
- *
- * Used to exempt explicit casts from TSN5110 errors.
- */
-export declare const hasExplicitDoubleIntent: (expr: IrExpression) => boolean;
-/**
- * Result of numeric coercion validation
- */
-export type NumericCoercionResult = {
-    readonly ok: boolean;
-    readonly module: IrModule;
-    readonly diagnostics: readonly Diagnostic[];
-};
-/**
- * Run numeric coercion validation on all modules.
  *
- * HARD GATE: If any diagnostics are returned, the emitter MUST NOT run.
+ * FACADE: Implementation split into numeric-classification.ts and numeric-validation.ts.
  */
-export declare const runNumericCoercionPass: (modules: readonly IrModule[]) => {
-    readonly ok: boolean;
-    readonly modules: readonly IrModule[];
-    readonly diagnostics: readonly Diagnostic[];
-};
+export { classifyNumericExpr, hasExplicitDoubleIntent, type NumericExprKind, } from "./numeric-classification.js";
+export { runNumericCoercionPass, type NumericCoercionResult, } from "./numeric-validation.js";
 //# sourceMappingURL=numeric-coercion-pass.d.ts.map

package/dist/ir/validation/numeric-coercion-pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numeric-coercion-pass.d.ts","sourceRoot":"","sources":["../../../src/ir/validation/numeric-coercion-pass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,UAAU,EAGX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,QAAQ,EAER,YAAY,EAIb,MAAM,aAAa,CAAC;AAcrB;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAQ7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,YAAY,KAAG,eA6GxD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,YAAY,KAAG,OAgB5D,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C,CAAC;AAqxBF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,SAAS,QAAQ,EAAE,KAC3B;IACD,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAc7C,CAAC"}
+{"version":3,"file":"numeric-coercion-pass.d.ts","sourceRoot":"","sources":["../../../src/ir/validation/numeric-coercion-pass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,yBAAyB,CAAC"}