@scriptc/compiler 0.0.3 → 0.0.5

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

@@ -1276,6 +1276,62 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out) {
         }
         return;
     }
+    // A CLASS-INSTANCE source (`const { previous, next } = path` —
+    // the path-walker idiom): the desugar IS JS's — one member read
+    // per element, left to right, at the element's pattern position:
+    // declared fields read their slots and accessor properties call
+    // their getters through the same fieldGetExpr dispatch as dotted
+    // reads (base-chain accessors and setter-only rejections resolve
+    // identically). Rest elements, methods, and names no class on the
+    // chain declares keep named fences (a detached method would lose its
+    // receiver silently; JS binds the prototype function).
+    if (srcType.kind === "object") {
+        const info = L.classes.get(srcType.className);
+        if (!info)
+            L.flushDeferredClass(srcType.className);
+        if (info) {
+            for (const el of pattern.elements) {
+                if (el.name === undefined)
+                    continue;
+                const loc = locOf(el);
+                if (el.dotDotDotToken) {
+                    L.unsupported("SC1031", el, "rest elements over class-instance sources (the remaining-properties object has no lowering yet)");
+                }
+                const prop = el.propertyName ?? el.name;
+                const propName = ts.isIdentifier(prop) || ts.isComputedPropertyName(prop) || ts.isStringLiteralLike(prop) || ts.isNumericLiteral(prop)
+                    ? patternKeyNameOf(L, prop)
+                    : null;
+                if (propName === null) {
+                    L.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
+                }
+                const fieldType = info.fields.get(propName);
+                const getF = fieldType === undefined ? L.findMethodOn(info, `get:${propName}`) : null;
+                const setF = fieldType === undefined ? L.findMethodOn(info, `set:${propName}`) : null;
+                let value;
+                if (fieldType !== undefined) {
+                    value = L.fieldGetExpr({ container: "class", obj: srcRef(), className: srcType.className, field: propName, fieldType }, loc, el);
+                }
+                else if (getF || setF) {
+                    value = L.fieldGetExpr({
+                        container: "accessor",
+                        obj: srcRef(),
+                        className: srcType.className,
+                        field: propName,
+                        fieldType: getF ? getF.sig.ret : setF.sig.params[0].type,
+                    }, loc, el);
+                }
+                else {
+                    L.unsupported("SC1031", el, L.findMethodOn(info, propName)
+                        ? `destructuring the method '${propName}' (a detached method loses its receiver — call it through the instance)`
+                        : `destructuring the property '${propName}' the class '${info.def.jsName ?? info.def.name}' does not declare`);
+                }
+                if (el.initializer)
+                    value = applyBindingDefault(L, el, value);
+                L.bindPatternTarget(el.name, value, isLet, out);
+            }
+            return;
+        }
+    }
     if (srcType.kind !== "record") {
         L.unsupported("SC1031", pattern, srcType.kind === "object"
             ? "object destructuring of class instances (read the fields directly — accessors make the desugar observable)"
@@ -2698,6 +2754,40 @@ function lowerDeleteStatement(L, expr) {
     }
     L.unsupported("SC1090", expr, `'delete' on '${L.fmt(obj.type)}' receivers (process.env keys and pure Record<string, T> keys delete)`);
 }
+/** The exact `Object.defineProperty(exports|module.exports, "__esModule",
+ * { value: true })` interop stamp (see the no-op lowering above). */
+function isEsModuleStamp(expr) {
+    if (!ts.isCallExpression(expr) || expr.questionDotToken !== undefined)
+        return false;
+    const callee = expr.expression;
+    if (!ts.isPropertyAccessExpression(callee) ||
+        !ts.isIdentifier(callee.expression) ||
+        callee.expression.text !== "Object" ||
+        !ts.isIdentifier(callee.name) ||
+        callee.name.text !== "defineProperty") {
+        return false;
+    }
+    if (expr.arguments.length !== 3)
+        return false;
+    const [recv, nameArg, desc] = expr.arguments;
+    const isExports = (ts.isIdentifier(recv) && recv.text === "exports") ||
+        (ts.isPropertyAccessExpression(recv) &&
+            ts.isIdentifier(recv.expression) &&
+            recv.expression.text === "module" &&
+            ts.isIdentifier(recv.name) &&
+            recv.name.text === "exports");
+    if (!isExports)
+        return false;
+    if (!ts.isStringLiteral(nameArg) || nameArg.text !== "__esModule")
+        return false;
+    if (!ts.isObjectLiteralExpression(desc) || desc.properties.length !== 1)
+        return false;
+    const p = desc.properties[0];
+    return (ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === "value" &&
+        p.initializer.kind === ts.SyntaxKind.TrueKeyword);
+}
 /** A top-level CommonJS export statement (see cjsExportAssignmentOf):
    * `exports.f = <expr>` and each expression-valued property of
    * `module.exports = { ... }` assign their pre-registered export globals
@@ -2739,6 +2829,56 @@ function lowerCjsExportStatement(L, cjs) {
         if (L.cjsMemberExportClassSymbol(cjs.expr) !== null) {
             return { kind: "block", body: [], loc };
         }
+        // The tsc VOID-INIT PREAMBLE (`exports.leaf = void 0;` with the real
+        // `exports.leaf = leaf;` further down — every tsc-emitted dist file
+        // opens its exports this way): the export global takes its value at
+        // the REAL assignment, and pushing undefined through a typed slot
+        // here would trap at module load. Node's only observable difference
+        // is a transient undefined between the two statements — reads in
+        // that window are the declaring module's own top-level code, which
+        // the real assignment's position already orders. Preambles with no
+        // later real assignment keep the ordinary path (the export IS
+        // undefined then).
+        if (ts.isIdentifier(cjs.name)) {
+            const isExportsMember = (e) => ts.isPropertyAccessExpression(e) &&
+                ts.isIdentifier(e.name) &&
+                ((ts.isIdentifier(e.expression) && e.expression.text === "exports") ||
+                    (ts.isPropertyAccessExpression(e.expression) &&
+                        ts.isIdentifier(e.expression.expression) &&
+                        e.expression.expression.text === "module" &&
+                        ts.isIdentifier(e.expression.name) &&
+                        e.expression.name.text === "exports"));
+            const isVoid = (e) => {
+                while (ts.isParenthesizedExpression(e))
+                    e = e.expression;
+                return e.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(e) && e.text === "undefined");
+            };
+            // chains: `exports.a = exports.b = void 0;` collects every name
+            const names = [cjs.name.text];
+            let tail = cjs.value;
+            while (ts.isBinaryExpression(tail) &&
+                tail.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                isExportsMember(tail.left)) {
+                names.push(tail.left.name.text);
+                tail = tail.right;
+            }
+            if (isVoid(tail)) {
+                const sfHere = cjs.expr.getSourceFile();
+                const myPos = cjs.expr.getStart(sfHere);
+                const laterRealOf = (name) => sfHere.statements.some((s) => {
+                    const other = cjsExportAssignmentOf(s);
+                    if (other?.kind !== "member" || !ts.isIdentifier(other.name))
+                        return false;
+                    if (other.name.text !== name)
+                        return false;
+                    if (other.expr.getStart(sfHere) <= myPos)
+                        return false;
+                    return !isVoid(other.value);
+                });
+                if (names.every(laterRealOf))
+                    return { kind: "block", body: [], loc };
+            }
+        }
         return assignExport(cjs.name, cjs.value);
     }
     let tableObj = cjs.obj;
@@ -2799,6 +2939,20 @@ function lowerCjsExportStatement(L, cjs) {
         // fence at the write site.
         if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop))
             continue;
+        // `...require('spec')` SPREAD entries are star-re-export plumbing
+        // (the bundler-emitted CJS canonical table — npm-static-rewrite.ts):
+        // importers of the spread names resolve statically through the
+        // TARGET module's own export machinery (the checker chases the
+        // spread; explicit member entries carry the values), and the module
+        // LOAD itself rides the ordinary import edge preflight collected —
+        // so no runtime copy exists to emit and the entry lowers to nothing.
+        if (ts.isSpreadAssignment(prop)) {
+            let inner = prop.expression;
+            while (ts.isParenthesizedExpression(inner))
+                inner = inner.expression;
+            if (requireSpecOf(inner) !== null)
+                continue;
+        }
         L.unsupported("SC1090", prop, "module.exports table entries beyond plain 'name: value' properties (methods, accessors, spreads, computed names)");
     }
     return { kind: "block", body, loc };
@@ -2946,6 +3100,15 @@ export function lowerExprStatement(L, expr) {
         const cjs = cjsExportAssignmentOf(stmtNode);
         if (cjs)
             return lowerCjsExportStatement(L, cjs);
+        // The tsc CJS interop stamp — `Object.defineProperty(exports,
+        // "__esModule", { value: true });` at a module's top — lowers to
+        // NOTHING: the compiled module system has no reflective exports
+        // object to mark, and the marker's one job (import interop) is
+        // already modeled statically by the checker and the CJS lexer link
+        // check. Every tsc-emitted dist file opens with it, and the generic
+        // defineProperty fence would throw at module load.
+        if (isEsModuleStamp(expr))
+            return { kind: "block", body: [], loc: locOf(expr) };
     }
     // Statement-position `delete` — the two honest receivers: process.env
     // keys (unsetenv(3) — later reads and spawned children observe the