@scriptc/compiler 0.1.2 → 0.1.3

package/dist/frontend/lowering/lower-calls.d.ts

@@ -394,12 +394,14 @@ export declare function lowerTaggedTemplate(lowerer: Lowerer, expr: ts.TaggedTem
    * FLATTENED namespace block count — splitFiles hoisted them into the
    * same collection lists top-level declarations ride. */
 export declare function isTopLevelFnSymbol(lowerer: Lowerer, ident: ts.Identifier): boolean;
-/** Nested `function name(...) {...}`: lowered as `const name = <lambda>`
-   * at the declaration's statement position (JS hoists function declarations
-   * to the top of the enclosing function — calling one before this statement
-   * is a compile error here, not a silent divergence). Self-references inside
-   * the body lower to `selfRef`, not a capture: a box holding its own
-   * closure would be an RC cycle. */
+/** Nested `function name(...) {...}`: declare the mutable function binding
+   * before lowering its body, then initialize it with the lifted closure.
+   * The early declaration is observable only when another nested closure
+   * captures the binding: its box must exist before either side of a mutual
+   * recursion cycle builds its closure. Forward source references use the
+   * same split declaration/assignment through predeclareForwardFnDecl.
+   * Self-references inside the body lower to `selfRef`, not a capture: a box
+   * holding its own closure would be an RC cycle. */
 export declare function lowerNestedFunctionDecl(lowerer: Lowerer, stmt: ts.FunctionDeclaration): IrStmt;
 /** Signature checks + param shapes + IR func type for any lambda-like
    * node. The func type's params are the ABI types, so a lambda with

package/dist/frontend/lowering/lower-calls.js

@@ -5,7 +5,7 @@ import { InternalCompilerError } from "../../errors.js";
  * generic instantiation (bounded by MAX_GENERIC_INSTANCES). */
 import * as ts from "../ts7/adapter.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
-import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
+import { BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { genResultRecord, isGenericCallableMemberType, typeKey } from "../type-mapper.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr } from "./lowerer.js";
@@ -16,7 +16,7 @@ import { mixinFnShapeOf } from "./lower-mixins.js";
 import { dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerTupleReadMethodCall } from "./lower-containers.js";
 import { bufEncoding } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
-import { lowerChildStreamMethodCall, lowerCreateRequireCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
+import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, lowerCreateRequireCall, lowerCryptoHashMethodCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
 import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, templateRawTextOf } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
@@ -3149,6 +3149,34 @@ export function lowerCall(lowerer, expr) {
     // Provenance-checked like setTimeout; zero-arg forms are the JS
     // constants ("", false, 0). `new String(...)` (wrapper objects) stays
     // on the SC2020 fence.
+    if (ts.isIdentifier(expr.expression) &&
+        expr.expression.text === "BigInt" &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
+        if (expr.arguments.length !== 1) {
+            lowerer.noLowering(`BigInt with ${expr.arguments.length} arguments`, expr);
+        }
+        const argNode = expr.arguments[0];
+        const arg = lowerer.lowerExpr(argNode);
+        if (arg.type.kind === "bigint")
+            return arg;
+        if (arg.type.kind === "string") {
+            return { kind: "libCall", fn: "bigint.parse", args: [arg], type: BIGINT_T, loc };
+        }
+        if (arg.type.kind === "f64") {
+            return { kind: "libCall", fn: "bigint.fromF64", args: [arg], type: BIGINT_T, loc };
+        }
+        if (arg.type.kind === "bool") {
+            return {
+                kind: "ternary",
+                cond: arg,
+                then: { kind: "libCall", fn: "bigint.parse", args: [{ kind: "strLit", value: "1", type: STRING, loc }], type: BIGINT_T, loc },
+                else_: { kind: "libCall", fn: "bigint.parse", args: [{ kind: "strLit", value: "0", type: STRING, loc }], type: BIGINT_T, loc },
+                type: BIGINT_T,
+                loc,
+            };
+        }
+        lowerer.noLowering(`BigInt of ${lowerer.fmt(arg.type)} values`, argNode, "string, number, boolean, and bigint arguments are supported");
+    }
     if (ts.isIdentifier(expr.expression) &&
         (expr.expression.text === "String" ||
             expr.expression.text === "Boolean" ||
@@ -3184,6 +3212,9 @@ export function lowerCall(lowerer, expr) {
         const arg = lowerer.lowerExpr(argNode);
         if (name === "String")
             return lowerer.ensureString(arg, argNode);
+        if (name === "Number" && arg.type.kind === "bigint") {
+            return { kind: "libCall", fn: "bigint.toF64", args: [arg], type: F64, loc };
+        }
         if (arg.type.kind === "f64")
             return arg;
         if (arg.type.kind === "bool") {
@@ -3922,10 +3953,12 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
+            lowerCryptoHashMethodCall(lowerer, expr, expr.expression) ??
             lowerFileHandleMethodCall(lowerer, expr, expr.expression) ??
             lowerer.lowerChildMethodCall(expr, expr.expression) ??
             // Piped child-output stream receivers — on/once("data" | "end").
             lowerChildStreamMethodCall(lowerer, expr, expr.expression) ??
+            lowerChildWriterMethodCall(lowerer, expr, expr.expression) ??
             // First-class process-stream receivers — write(data).
             lowerProcStreamMethodCall(lowerer, expr, expr.expression) ??
             // FSWatcher receivers — close() (fs.watch's handle).
@@ -4008,6 +4041,8 @@ export function lowerCall(lowerer, expr) {
             // by the receiver's own element.
             lowerer.lowerFilterNarrowCall(expr, expr.expression) ??
             lowerArrayIsArrayCall(lowerer, expr, expr.expression) ??
+            lowerBigIntStaticCall(lowerer, expr, expr.expression) ??
+            lowerBigIntMethodCall(lowerer, expr, expr.expression) ??
             lowerSymbolStaticCall(lowerer, expr, expr.expression) ??
             lowerSymbolMethodCall(lowerer, expr, expr.expression) ??
             lowerRegExpStaticCall(lowerer, expr, expr.expression) ??
@@ -5527,19 +5562,38 @@ export function isTopLevelFnSymbol(lowerer, ident) {
         ts.isFunctionDeclaration(decl) &&
         (ts.isSourceFile(decl.parent) || lowerer.nsBlocks.get(decl.parent) === "flattened"));
 }
-/** Nested `function name(...) {...}`: lowered as `const name = <lambda>`
-   * at the declaration's statement position (JS hoists function declarations
-   * to the top of the enclosing function — calling one before this statement
-   * is a compile error here, not a silent divergence). Self-references inside
-   * the body lower to `selfRef`, not a capture: a box holding its own
-   * closure would be an RC cycle. */
+/** Nested `function name(...) {...}`: declare the mutable function binding
+   * before lowering its body, then initialize it with the lifted closure.
+   * The early declaration is observable only when another nested closure
+   * captures the binding: its box must exist before either side of a mutual
+   * recursion cycle builds its closure. Forward source references use the
+   * same split declaration/assignment through predeclareForwardFnDecl.
+   * Self-references inside the body lower to `selfRef`, not a capture: a box
+   * holding its own closure would be an RC cycle. */
 export function lowerNestedFunctionDecl(lowerer, stmt) {
     if (!stmt.name)
         lowerer.unsupported("SC1090", stmt, "anonymous function declarations");
     const { funcType } = lowerer.lambdaSignature(stmt);
-    const local = lowerer.declareLocal(stmt.name, stmt.name.text, funcType, false);
+    // Function declaration bindings are mutable in JavaScript. More
+    // importantly, putting the empty slot into the owning statement list
+    // BEFORE lowerLambda lets a sibling lowered from that body capture this
+    // local's eventual box. The local object may become boxed while either
+    // body lowers; backends inspect its final shape when emitting varDecl.
+    const local = lowerer.declareLocal(stmt.name, stmt.name.text, funcType, true);
+    let declared = false;
+    for (let i = lowerer.activeStmtLists.length - 1; i >= 0; i--) {
+        const entry = lowerer.activeStmtLists[i];
+        if (entry.ctx !== lowerer.ctx || !entry.stmts.includes(stmt))
+            continue;
+        entry.out.push({ kind: "varDecl", localId: local.id, init: null, loc: locOf(stmt) });
+        declared = true;
+        break;
+    }
+    if (!declared) {
+        throw new InternalCompilerError("lowerer bug: nested function declaration has no active statement list");
+    }
     const init = lowerer.lowerLambda(stmt);
-    return { kind: "varDecl", localId: local.id, init, loc: locOf(stmt) };
+    return { kind: "assign", localId: local.id, value: init, loc: locOf(stmt) };
 }
 /** Signature checks + param shapes + IR func type for any lambda-like
    * node. The func type's params are the ABI types, so a lambda with
@@ -5765,11 +5819,13 @@ export function lowerLambda(lowerer, node) {
                 // the validator's bare-unitLit rule (typeCheckReturnExpression).
                 // A `void e` body rides the statement lowering (the value is
                 // discarded here, so the operand evaluates for effect alone —
-                // `(name) => void doThing(name)`, the fire-and-forget arrow).
+                // `(name) => void doThing(name)`, the fire-and-forget arrow). A
+                // conditional body does the same so its void arms become lazy
+                // statement branches instead of a forbidden void-valued ternary.
                 let stripped = bodyExpr;
                 while (ts.isParenthesizedExpression(stripped))
                     stripped = stripped.expression;
-                if (ts.isVoidExpression(stripped)) {
+                if (ts.isVoidExpression(stripped) || ts.isConditionalExpression(stripped)) {
                     body = [lowerer.lowerExprStatement(stripped)];
                 }
                 else {
@@ -6769,6 +6825,48 @@ function lowerSymbolStaticCall(lowerer, call, access) {
     }
     lowerer.unsupported("SC1090", call, `well-known symbols as values (Symbol.${member} — for-of, iteration protocols, and template literals compile through their language constructs; the reified symbol has no static lowering)`);
 }
+function lowerBigIntStaticCall(lowerer, call, access) {
+    if (call.questionDotToken || access.questionDotToken)
+        return null;
+    if (!lowerer.isStdlibGlobal(access.expression, "BigInt"))
+        return null;
+    const name = access.name.text;
+    if (name !== "asUintN" && name !== "asIntN")
+        return null;
+    if (call.arguments.length !== 2) {
+        lowerer.noLowering(`BigInt.${name} with ${call.arguments.length} arguments`, call);
+    }
+    const loc = locOf(call);
+    const bits = lowerer.lowerExprExpecting(call.arguments[0], F64);
+    const value = lowerer.lowerExprExpecting(call.arguments[1], BIGINT_T);
+    return {
+        kind: "libCall",
+        fn: name === "asUintN" ? "bigint.asUintN" : "bigint.asIntN",
+        args: [bits, value],
+        type: BIGINT_T,
+        loc,
+    };
+}
+function lowerBigIntMethodCall(lowerer, call, access) {
+    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "bigint")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const name = access.name.text;
+    const loc = locOf(call);
+    const receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind !== "bigint")
+        return null;
+    if (name === "valueOf" && call.arguments.length === 0)
+        return receiver;
+    if (name === "toString" && call.arguments.length <= 1) {
+        const radix = call.arguments[0]
+            ? lowerer.lowerExprExpecting(call.arguments[0], F64)
+            : { kind: "numLit", value: 10, type: F64, loc };
+        return { kind: "libCall", fn: "bigint.toString", args: [receiver, radix], type: STRING, loc };
+    }
+    return null;
+}
 /** Method calls on symbol-typed receivers: `.toString()` is the
  * "Symbol(desc)" text (Node's Symbol.prototype.toString — note that
  * template literals and concatenation THROW in JS and stay fenced;