@tsonic/emitter 0.0.73 → 0.0.75

package/dist/core/semantic/boolean-condition-union.js

@@ -0,0 +1,238 @@
+/**
+ * Union truthiness emission for boolean conditions (AST-native).
+ *
+ * Handles the per-variant truthiness logic for union types:
+ * - (T | null | undefined) nullable unions
+ * - literal unions (e.g., "a" | "b")
+ * - 2+ member compiler-owned runtime union carriers
+ * - fallback for broad/object-like unions emitted as object
+ */
+import { allocateLocalName } from "../format/local-names.js";
+import { isRuntimeNullishType, splitRuntimeNullishUnionMembers, } from "./type-resolution.js";
+import { buildRuntimeUnionLayout, buildRuntimeUnionTypeAst, } from "./runtime-unions.js";
+import { booleanLiteral, nullLiteral } from "../format/backend-ast/builders.js";
+import { emitRuntimeTruthinessConditionAst, getLiteralUnionBasePrimitive, identifierExpr, wrapForIs, } from "./truthiness-evaluation.js";
+// ============================================================
+// Union truthiness (AST-native)
+// ============================================================
+export const emitUnionTruthinessConditionAst = (expr, emittedAst, unionType, context, toBooleanConditionAstFn, emitTypeAst) => {
+    // Align boolean-context emission with union type emission:
+    // - (T | null | undefined) behaves like a nullable (falsy when nullish)
+    // - literal unions behave like their primitive base at runtime
+    // - carried runtime unions require per-variant truthiness
+    const runtimeNullishSplit = splitRuntimeNullishUnionMembers(unionType);
+    const nonNullTypes = runtimeNullishSplit?.nonNullishMembers ?? unionType.types;
+    const hasNullish = runtimeNullishSplit?.hasRuntimeNullish ?? false;
+    const literalBase = getLiteralUnionBasePrimitive(nonNullTypes);
+    if (literalBase) {
+        const baseType = {
+            kind: "primitiveType",
+            name: literalBase,
+        };
+        if (!hasNullish) {
+            return toBooleanConditionAstFn({ ...expr, inferredType: baseType }, emittedAst, context);
+        }
+        // Nullable literal union (e.g. "a" | "b" | null) → value is falsy when nullish.
+        const nextId = (context.tempVarId ?? 0) + 1;
+        const ctxWithId = { ...context, tempVarId: nextId };
+        const alloc = allocateLocalName(`__tsonic_truthy_nullable_${nextId}`, ctxWithId);
+        const tmp = alloc.emittedName;
+        const [innerCondAst, innerCtx] = toBooleanConditionAstFn({
+            kind: "identifier",
+            name: tmp,
+            inferredType: baseType,
+        }, identifierExpr(tmp), alloc.context);
+        const emittedNonNull = literalBase === "string"
+            ? "string"
+            : literalBase === "number"
+                ? "double"
+                : "bool";
+        // Build: (operand is Type tmp && innerCond)
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "isExpression",
+                        expression: wrapForIs(emittedAst),
+                        pattern: {
+                            kind: "declarationPattern",
+                            type: { kind: "predefinedType", keyword: emittedNonNull },
+                            designation: tmp,
+                        },
+                    },
+                    right: innerCondAst,
+                },
+            },
+            innerCtx,
+        ];
+    }
+    // Nullable union: (T | null | undefined) → treat as `T?` truthiness.
+    if (hasNullish && nonNullTypes.length === 1) {
+        const nonNull = nonNullTypes[0];
+        if (!nonNull)
+            return [booleanLiteral(false), context];
+        // For non-primitive nullable unions (e.g. `T[] | undefined`, `SomeRef | null`),
+        // emit truthiness directly against the operand with non-null inferred type.
+        // This avoids nested nullable pattern variables while preserving exact semantics.
+        if (nonNull.kind !== "primitiveType") {
+            return emitRuntimeTruthinessConditionAst(emittedAst, context);
+        }
+        const nextId = (context.tempVarId ?? 0) + 1;
+        const ctxWithId = { ...context, tempVarId: nextId };
+        const alloc = allocateLocalName(`__tsonic_truthy_nullable_${nextId}`, ctxWithId);
+        const tmp = alloc.emittedName;
+        // Pattern-match the non-null value into a strongly-typed temp and apply truthiness to it.
+        // This handles both nullable value types (int?) and nullable reference types (string?).
+        const [innerCondAst, innerCtx] = toBooleanConditionAstFn({
+            kind: "identifier",
+            name: tmp,
+            inferredType: nonNull,
+        }, identifierExpr(tmp), alloc.context);
+        const emittedNonNull = nonNull.name === "number"
+            ? "double"
+            : nonNull.name === "int"
+                ? "int"
+                : nonNull.name === "string"
+                    ? "string"
+                    : nonNull.name === "boolean"
+                        ? "bool"
+                        : nonNull.name === "char"
+                            ? "char"
+                            : "object";
+        // Build: (operand is Type tmp && innerCond)
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "isExpression",
+                        expression: wrapForIs(emittedAst),
+                        pattern: {
+                            kind: "declarationPattern",
+                            type: { kind: "predefinedType", keyword: emittedNonNull },
+                            designation: tmp,
+                        },
+                    },
+                    right: innerCondAst,
+                },
+            },
+            innerCtx,
+        ];
+    }
+    // Carried runtime unions use per-variant carriers. We must inspect the active variant.
+    const [runtimeLayout, layoutContext] = buildRuntimeUnionLayout(unionType, context, emitTypeAst);
+    if (runtimeLayout) {
+        const runtimeMembers = runtimeLayout.members;
+        const runtimeUnionTypeAst = buildRuntimeUnionTypeAst(runtimeLayout);
+        const nextId = (layoutContext.tempVarId ?? 0) + 1;
+        const ctxWithId = {
+            ...layoutContext,
+            tempVarId: nextId,
+        };
+        const alloc = allocateLocalName(`__tsonic_truthy_union_${nextId}`, ctxWithId);
+        const u = alloc.emittedName;
+        // Build per-member truthiness ASTs
+        let chainCtx = alloc.context;
+        const branchAsts = [];
+        for (let i = 0; i < runtimeMembers.length; i++) {
+            const memberN = i + 1;
+            const memberType = runtimeMembers[i];
+            if (!memberType || isRuntimeNullishType(memberType)) {
+                branchAsts.push(booleanLiteral(false));
+                continue;
+            }
+            const memberEmittedAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: identifierExpr(u),
+                    memberName: `As${memberN}`,
+                },
+                arguments: [],
+            };
+            const [memberCondAst, memberCtx] = toBooleanConditionAstFn({
+                kind: "identifier",
+                name: `${u}__${memberN}`,
+                inferredType: memberType,
+            }, memberEmittedAst, chainCtx);
+            branchAsts.push(memberCondAst);
+            chainCtx = memberCtx;
+        }
+        // Build nested conditional chain: u.Is1() ? (cond1) : u.Is2() ? (cond2) : ...
+        const buildChain = (start) => {
+            const last = branchAsts[branchAsts.length - 1];
+            if (start === branchAsts.length - 1) {
+                return last ?? booleanLiteral(false);
+            }
+            const branch = branchAsts[start];
+            return {
+                kind: "conditionalExpression",
+                condition: {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "memberAccessExpression",
+                        expression: identifierExpr(u),
+                        memberName: `Is${start + 1}`,
+                    },
+                    arguments: [],
+                },
+                whenTrue: {
+                    kind: "parenthesizedExpression",
+                    expression: branch ?? booleanLiteral(false),
+                },
+                whenFalse: {
+                    kind: "parenthesizedExpression",
+                    expression: buildChain(start + 1),
+                },
+            };
+        };
+        const chainAst = buildChain(0);
+        // Build: (operand is UnionN_HASH<T...> u && u is not null && (chain))
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "binaryExpression",
+                        operatorToken: "&&",
+                        left: {
+                            kind: "isExpression",
+                            expression: wrapForIs(emittedAst),
+                            pattern: {
+                                kind: "declarationPattern",
+                                type: runtimeUnionTypeAst,
+                                designation: u,
+                            },
+                        },
+                        right: {
+                            kind: "isExpression",
+                            expression: identifierExpr(u),
+                            pattern: {
+                                kind: "negatedPattern",
+                                pattern: {
+                                    kind: "constantPattern",
+                                    expression: nullLiteral(),
+                                },
+                            },
+                        },
+                    },
+                    right: {
+                        kind: "parenthesizedExpression",
+                        expression: chainAst,
+                    },
+                },
+            },
+            chainCtx,
+        ];
+    }
+    // Fallback for unions >8 (emitted as object): runtime truthiness matches JS semantics.
+    return emitRuntimeTruthinessConditionAst(emittedAst, context);
+};
+//# sourceMappingURL=boolean-condition-union.js.map

package/dist/core/semantic/boolean-condition-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-union.js","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-union.ts"],"names":[],"mappings":"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"}

package/dist/core/semantic/boolean-context.d.ts

@@ -1,44 +1,10 @@
 /**
- * Boolean-context emission (truthiness / ToBoolean)
+ * Boolean-context emission (truthiness / ToBoolean) — facade module.
  *
- * In TypeScript, any value can be used in a boolean context (truthy/falsy).
- * In C#, only boolean expressions are valid conditions (if/while/for/?:/!).
- *
- * This module provides a shared, deterministic lowering for boolean contexts.
- * All functions return typed CSharpExpressionAst nodes — no text bridging.
- *
- * IMPORTANT:
- * - This operates on IR + emitted AST; it must not import emitExpressionAst to avoid cycles.
- * - Callers provide an emit function.
- */
-import type { IrExpression, IrType } from "@tsonic/frontend";
-import type { EmitterContext } from "../../types.js";
-import type { CSharpExpressionAst } from "../format/backend-ast/types.js";
-export type EmitExprAstFn = (expr: IrExpression, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
-/**
- * Convert an expression to a valid C# boolean condition, returning a typed AST node.
- *
- * Rules (deterministic):
- * - Booleans: use as-is
- * - Reference types (objects, arrays, dictionaries, unions, ...): runtime truthiness
- * - Strings: `!string.IsNullOrEmpty(expr)`
- * - Numbers: JS truthiness check: false iff 0 or NaN
- * - int: `expr != 0`
- * - char: `expr != '\0'`
- * - null/undefined literals: `false`
- */
-export declare const toBooleanConditionAst: (expr: IrExpression, emittedAst: CSharpExpressionAst, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
-/**
- * Emit a boolean-context expression as a typed AST node.
- *
- * Special-cases logical &&/|| into proper binaryExpression AST nodes
- * with printer-handled parenthesization.
- */
-export declare const emitBooleanConditionAst: (expr: IrExpression, emitExprAst: EmitExprAstFn, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
-/**
- * Whether a type is boolean.
- *
- * Used by callers that need a fast check (e.g., logical operator selection).
+ * Re-exports the public API from the implementation sub-modules:
+ * - truthiness-evaluation.ts  — AST helpers, runtime truthiness, isBooleanType
+ * - boolean-condition-emission.ts — toBooleanConditionAst, emitBooleanConditionAst
  */
-export declare const isBooleanType: (type: IrType | undefined) => boolean;
+export { isBooleanType } from "./truthiness-evaluation.js";
+export { type EmitExprAstFn, toBooleanConditionAst, emitBooleanConditionAst, } from "./boolean-condition-emission.js";
 //# sourceMappingURL=boolean-context.d.ts.map

package/dist/core/semantic/boolean-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-context.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/boolean-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,gCAAgC,CAAC;AAExC,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,cAAc,KACpB,CAAC,mBAAmB,EAAE,cAAc,CAAC,CAAC;AA+pB3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,YAAY,EAClB,YAAY,mBAAmB,EAC/B,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CA6KtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,YAAY,EAClB,aAAa,aAAa,EAC1B,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CA6BtC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OAExD,CAAC"}
+{"version":3,"file":"boolean-context.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/boolean-context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EACL,KAAK,aAAa,EAClB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,iCAAiC,CAAC"}