@scriptc/compiler 0.2.1 → 0.2.2

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

@@ -19,19 +19,19 @@ import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, hasExplicitJsDocReturn, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { isCompiledPrototypeMember } from "./class-prototypes.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
-import { classPropertiesHelper } from "./class-dynamic-dispatch.js";
+import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
 import { genericIfaceBindingKeepsClass, staticFieldWriteTarget } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
@@ -71,6 +71,8 @@ function npmStaticReturnedEmptyArrayType(lowerer, decl) {
     const ownerBody = owner !== undefined && ts.isFunctionLike(owner) ? owner.body : undefined;
     if (ownerBody === undefined || !ts.isBlock(ownerBody))
         return null;
+    if (owner && ts.isFunctionLike(owner) && !owner.type && !hasExplicitJsDocReturn(owner))
+        return null;
     let returned = false;
     ts.walkPreorder(ownerBody, (node) => {
         if (node !== ownerBody && ts.isFunctionLike(node))
@@ -593,7 +595,12 @@ export function predeclareForwardCapture(lowerer, symbol) {
         // TDZ read until the initializing assign completes — JS exactly.
         if (idx < entry.index || entry.ctx === lowerer.ctx || entry.ctx.tdzPredeclared.has(symbol))
             return false;
-        const type = lowerer.irTypeOf(decl.name);
+        let type = lowerer.irTypeOf(decl.name);
+        if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+            (ts.isObjectLiteralExpression(decl.initializer) ||
+                (ts.isCallExpression(decl.initializer) && ts.isPropertyAccessExpression(decl.initializer.expression) &&
+                    decl.initializer.expression.name.text === "assign" && lowerer.isStdlibGlobal(decl.initializer.expression.expression, "Object"))) && lowerer.dynConvertible(type))
+            type = DYN;
         if (!TDZ_KINDS.has(type.kind) || isUnitType(type))
             return false;
         const name = decl.name.text;
@@ -1035,12 +1042,9 @@ export function lowerStmt(lowerer, stmt) {
         // (JS), which the undefined arm carries — tsc only allows the bare
         // form when the return type includes undefined/void. A CHECKED-
         // DYNAMIC return slot holds the dyn undefined directly (the
-        // appendImplicitUndefinedReturn rule). What remains is JS-only —
-        // a JSDoc return claim the body contradicts (ms's parse: `@return
-        // {Number}` with a bare early `return;`): no undefined fits the
-        // declared representation, so the statement fences honestly (the
-        // per-statement JS deferral — the claimed paths still run) instead
-        // of slipping an empty return past the validator.
+        // appendImplicitUndefinedReturn rule). JavaScript signatures include
+        // observed empty returns even when JSDoc omits undefined. Any remaining
+        // incompatible boundary keeps the ordinary per-statement refusal.
         let value = null;
         if (stmt.expression) {
             return lowerer.lowerReturnStmt(stmt.expression, locOf(stmt));
@@ -1885,6 +1889,10 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // scoped TypeScript exception: its declared result/token types are
     // deliberately carried by the checked-dynamic tree, so their ordinary
     // object patterns use the same exact keyed-read desugar.
+    if (srcType.kind === "union" && isJsSourceFile(pattern.getSourceFile()) && lowerer.dynConvertible(srcType)) {
+        lowerer.lowerBindingPattern(pattern, () => lowerer.coerceToExpected(srcRef(), DYN), DYN, isLet, out, dynSpell, allowDynObject);
+        return;
+    }
     if (srcType.kind === "dyn") {
         for (const el of pattern.elements) {
             if (el.name === undefined)
@@ -3323,7 +3331,7 @@ function inferredEvolvingLetType(lowerer, decl) {
                     invalid = true;
                     return "stop";
                 }
-                if (ts.isCallExpression(node.right) && implicitMethodCallInfersReturn(lowerer, node.right)) {
+                if (ts.isCallExpression(node.right) && (implicitMethodCallInfersReturn(lowerer, node.right) || isJsSourceFile(node.right.getSourceFile()))) {
                     invalid = true;
                     return "stop";
                 }
@@ -3545,7 +3553,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         : (declSymbol ? lowerer.globalsBySymbol.get(declSymbol) : undefined);
     if (g) {
         let promotedGlobal = lowerer.runtimeOptionalBindingType(decl.name, g.type);
-        if (g.type.kind === "func" && decl.initializer !== undefined && ts.isIdentifier(decl.initializer)) {
+        if (g.type.kind === "func" && !decl.type && !hasJsTypeAnnotation(decl) &&
+            decl.initializer !== undefined && ts.isIdentifier(decl.initializer)) {
             const sig = lowerer.fnSigOf(decl.initializer);
             if (sig) {
                 promotedGlobal = {
@@ -3579,6 +3588,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         }
         const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" && (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
             ts.isArrayLiteralExpression(decl.initializer) || ts.isObjectLiteralExpression(decl.initializer)) ? DYN : undefined);
+        if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && raw.type.kind === "dyn" &&
+            (g.type.kind === "record" || g.type.kind === "object"))
+            g.type = DYN;
+        g.type = inferredOptionalRecordType(lowerer, decl, g.type, raw.type);
         const arithmetic = raw.type.kind === "union"
             ? lowerer.unions.get(raw.type.unionId)?.arms
             : undefined;
@@ -3651,7 +3664,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         ? lowerer.unions.get(inferredObjectType.unionId)?.arms ?? [] : inferredObjectType ? [inferredObjectType] : [];
     const expandsObject = !decl.type && !hasJsTypeAnnotation(decl) && inferredObjectType !== null &&
         jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn" ||
-        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm));
+        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm)) ||
+        isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+            ts.isObjectLiteralExpression(decl.initializer) && decl.initializer.properties.some((property) => ts.isMethodDeclaration(property) || ts.isAccessor(property) || ts.isPropertyAssignment(property) &&
+            (ts.isFunctionExpression(property.initializer) || ts.isArrowFunction(property.initializer)));
     let init;
     try {
         init = expandsObject || (isJsSourceFile(decl.getSourceFile()) && !decl.type &&
@@ -3806,6 +3822,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         type = init.type;
         runtimeOptional = true;
     }
+    if (type !== null)
+        type = inferredOptionalRecordType(lowerer, decl, type, init.type);
     // A JS binding whose checker type spells a FUNCTION but whose VALUE is
     // already checked-dynamic (`const cb = mustCall(fn)` — the helper's
     // return rides its own box): keep the box. Extracting into the spelled
@@ -3817,6 +3835,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             !decl.type && !hasJsTypeAnnotation(decl) && type.rest === true && type.restAbi === undefined)) {
         type = DYN;
     }
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && init.type.kind === "dyn" &&
+        (type?.kind === "record" || type?.kind === "object"))
+        type = DYN;
     // A checker-`any` CONST whose initializer lowered to a STATIC type
     // (`const name = rawName ? rawName.replace(...) : null` — the
     // dyn-receiver machinery and the any-ternary join answer static IR):
@@ -3987,6 +4008,21 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
+// lib.d.ts declares named captures as strings, but nonparticipating captures
+// are undefined. Inferred index records retain that runtime representation;
+// explicit annotations still require a checked conversion at the boundary.
+function inferredOptionalRecordType(lowerer, decl, declared, actual) {
+    if (decl.type || hasJsTypeAnnotation(decl) || declared.kind !== "record" || actual.kind !== "record")
+        return declared;
+    const target = lowerer.shapes.get(declared.shapeId);
+    const source = lowerer.shapes.get(actual.shapeId);
+    if (!target || !source || target.fields.length || source.fields.length || target.tuple || source.tuple ||
+        !target.indexValue || source.indexValue?.kind !== "union" ||
+        lowerer.armTag(source.indexValue.unionId, UNDEFINED_T) < 0 ||
+        !typeEquals(lowerer.stripUndefinedArm(source.indexValue), target.indexValue))
+        return declared;
+    return actual;
+}
 function lowerVariableInitializer(lowerer, node, expected) {
     let value = node;
     while (ts.isParenthesizedExpression(value) ||
@@ -4132,18 +4168,24 @@ export function jsBindingHasOpenWrites(lowerer, decl) {
     let owner = decl;
     while (owner.parent && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
         owner = owner.parent;
-    let open = false;
-    ts.walkPreorder(owner, (node) => {
-        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && ts.isIdentifier(node.left) &&
-            lowerer.resolveValueSymbol(node.left) === symbol &&
-            (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
-            open = true;
-            return "stop";
-        }
-        return undefined;
-    });
-    return open;
+    let writes = lowerer.jsBindingWritesByOwner.get(owner);
+    if (!writes) {
+        const indexed = new Map();
+        ts.walkPreorder(owner, (node) => {
+            if (!ts.isBinaryExpression(node) || node.operatorToken.kind < ts.SyntaxKind.FirstAssignment ||
+                node.operatorToken.kind > ts.SyntaxKind.LastAssignment || !ts.isIdentifier(node.left))
+                return;
+            const entries = indexed.get(node.left.text);
+            if (entries)
+                entries.push(node);
+            else
+                indexed.set(node.left.text, [node]);
+        });
+        writes = indexed;
+        lowerer.jsBindingWritesByOwner.set(owner, writes);
+    }
+    return (writes.get(decl.name.text) ?? []).some((node) => lowerer.resolveValueSymbol(node.left) === symbol &&
+        (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
 }
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
     if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
@@ -4257,11 +4299,10 @@ function lowerDynSwitch(lowerer, stmt, disc, labels) {
         if (test.kind === "unitLit") {
             return { kind: "dynTest", test: test.unit, value: stableDisc, type: BOOL, loc: locOf(expression) };
         }
-        if (test.type.kind !== "string" && test.type.kind !== "f64" &&
-            test.type.kind !== "bool" && test.type.kind !== "dyn") {
+        if (!lowerer.dynConvertible(test.type)) {
             lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
         }
-        return { kind: "dynScalarEq", left: stableDisc, right: test, type: BOOL, loc: locOf(expression) };
+        return { kind: "dynScalarEq", left: stableDisc, right: lowerer.coerceInto(expression, test, DYN), type: BOOL, loc: locOf(expression) };
     });
 }
 function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
@@ -5213,6 +5254,13 @@ export function lowerExprStatement(lowerer, expr) {
                 }
                 if (!expr.left.questionDotToken) {
                     const recv = tryLowerExpression(lowerer, expr.left.expression);
+                    if (recv && (recv.type.kind === "dyn" || isJsSourceFile(expr.getSourceFile()) &&
+                        recv.type.kind === "union" && lowerer.dynConvertible(recv.type))) {
+                        const loc = locOf(expr);
+                        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [lowerer.coerceInto(expr.left.expression, recv, DYN),
+                                    { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                    lowerer.lowerExprExpecting(expr.right, DYN)], type: VOID, loc }, loc };
+                    }
                     if (recv?.type.kind === "object" && recv.type.className === "%Error") {
                         const loc = locOf(expr);
                         return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [
@@ -5322,6 +5370,16 @@ export function lowerExprStatement(lowerer, expr) {
     if ((ts.isPrefixUnaryExpression(expr) || ts.isPostfixUnaryExpression(expr)) &&
         (expr.operator === ts.SyntaxKind.PlusPlusToken ||
             expr.operator === ts.SyntaxKind.MinusMinusToken)) {
+        if (ts.isPropertyAccessExpression(expr.operand) || ts.isElementAccessExpression(expr.operand)) {
+            // Statement and value positions share ToNumeric and reference order.
+            // Namespace/expando globals retain their direct binding path below.
+            const binding = ts.isPropertyAccessExpression(expr.operand)
+                ? expandoWritableTarget(lowerer, expr.operand) ?? nsWritableTarget(lowerer, expr.operand)
+                : null;
+            if (binding)
+                return lowerIncDecToTarget(lowerer, expr, binding);
+            return { kind: "exprStmt", expr: lowerIncDec(lowerer, expr, ts.isPrefixUnaryExpression(expr)), loc: locOf(expr) };
+        }
         // Statement position only: pre/post distinction is unobservable, so
         // both desugar to `x = x ± 1`.
         if (ts.isPropertyAccessExpression(expr.operand) ||
@@ -7822,9 +7880,8 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
    *   properties, so the enumeration is honestly EMPTY (zero iterations;
    *   the body typechecked but never evaluates — SEMANTICS.md documents
    *   the divergence).
-   * - class instances fence: which keys exist on one depends on runtime
-   *   property creation (unset declared fields, useDefineForClassFields)
-   *   that the struct model does not track — named, not guessed.
+   * - JavaScript program classes use their live property-creation table.
+   *   TypeScript and runtime-owned layouts keep the class-instance fence.
    * Bindings mirror for-of's: const/let declare the per-iteration string
    * local, `var` assigns the hoisted shared slot, a pre-declared
    * identifier target assigns per pass; destructuring heads are tsc
@@ -7835,7 +7892,17 @@ function lowerForIn(lowerer, stmt) {
     if (stdlibGlobalNameOf(lowerer, stmt.expression) === "globalThis") {
         return { kind: "block", body: [], loc };
     }
-    const receiver = lowerer.lowerExpr(stmt.expression);
+    let receiver = lowerer.lowerExpr(stmt.expression);
+    if (receiver.type.kind === "object") {
+        const info = lowerer.classes.get(receiver.type.className);
+        let root = info;
+        while (root?.base)
+            root = root.base;
+        if (info?.decl && isJsSourceFile(info.decl.getSourceFile()) && !info.def.runtime &&
+            !root?.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream) {
+            receiver = lowerer.coerceToExpected(receiver, DYN);
+        }
+    }
     const recvT = receiver.type;
     if (recvT.kind === "dyn") {
         const recv = lowerer.declareHiddenLocal("%indyn", DYN);
@@ -7844,9 +7911,7 @@ function lowerForIn(lowerer, stmt) {
             kind: "dynCheck", value: { kind: "libCall", fn: "dyn.forInKeys", args: [ref], type: DYN, loc },
             type: arrayOf(STRING), loc,
         };
-        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => ({
-            kind: "libCall", fn: "dyn.hasKey", args: [ref, key], type: BOOL, loc,
-        }));
+        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => classForInHasKey(lowerer, ref, key, loc));
         return { kind: "block", body: [{ kind: "varDecl", localId: recv.id, init: receiver, loc }, loop], loc };
     }
     if (recvT.kind === "array")