@scriptc/compiler 0.4.3 → 0.4.4

package/dist/frontend/program.d.ts

@@ -130,13 +130,21 @@ declare function requireSpecOf7(node: ts.Node): string | null;
  * These lower to NOTHING — the bindings are alias plumbing (tsc models
  * them as import aliases) and the module edge lives in the order walk. */
 declare function isRequireStatement7(stmt: ts.Statement): boolean;
-/** The require() occurrences of one top-level statement: the declaration
- * forms and the bare side-effect call. Empty for everything else. */
-declare function requiresOf7(stmt: ts.Statement): {
+/** A require() occurrence of a top-level statement. `split` marks the
+ * assignment of a split require binding (splitRequireBindings7): `node`
+ * is its require call and `decl` the binding's declaration. */
+interface RequireOccurrence7 {
     spec: string;
     node: ts.Node;
     decl: ts.VariableDeclaration | null;
-}[];
+    split?: true;
+}
+/** The require() occurrences of one top-level statement: the declaration
+ * forms, the bare side-effect call, and the assignment of a split require
+ * binding. Empty for everything else. */
+declare function requiresOf7(stmt: ts.Statement, program: ts.Program): RequireOccurrence7[];
+/** The require call of a split require binding's declaration, or null. */
+declare function splitRequireCallOf7(program: ts.Program, decl: ts.VariableDeclaration): ts.CallExpression | null;
 /** The exact `Object.defineProperty(exports|module.exports, "__esModule",
  * { value: true })` interop stamp (shared by preflight and the no-op lowering);
  * `{ value: !0 }` is the same stamp. */
@@ -301,7 +309,7 @@ export declare function esmNamedImportLinkCrash(program: ts.Program, entry: ts.S
 export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
 export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
 export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
-export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
+export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
 /** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
  * types come entirely from inference (checkJs + JSDoc) and whose classes
  * declare fields by constructor assignment. */

package/dist/frontend/program.js

@@ -1087,6 +1087,11 @@ function suppressedJsStrictness7(d) {
     if (JS_ANY_OPERATOR_CODES.has(d.code)) {
         return ts.flattenDiagnosticMessageText(d, "\n").includes("'any'");
     }
+    // The deprecated Buffer(...) call without `new`, which Node's Buffer
+    // function accepts (containers/bytes.ts lowers it).
+    if (d.code === 2348) {
+        return ts.flattenDiagnosticMessageText(d, "\n").includes("'BufferConstructor'");
+    }
     return false;
 }
 /** The specifier of a `require("...")` call: the callee is the bare
@@ -1126,9 +1131,15 @@ function isRequireStatement7(stmt) {
         decls.every((d) => d.initializer !== undefined && requireSpecOf7(d.initializer) !== null));
 }
 /** The require() occurrences of one top-level statement: the declaration
- * forms and the bare side-effect call. Empty for everything else. */
-function requiresOf7(stmt) {
+ * forms, the bare side-effect call, and the assignment of a split require
+ * binding. Empty for everything else. */
+function requiresOf7(stmt, program) {
     if (ts.isExpressionStatement(stmt)) {
+        const split = splitRequireOfStatement7(program, stmt);
+        if (split !== null)
+            return [
+                { spec: requireSpecOf7(split.call), node: split.call, decl: split.decl, split: true },
+            ];
         const spec = requireSpecOf7(stmt.expression);
         return spec !== null ? [{ spec, node: stmt.expression, decl: null }] : [];
     }
@@ -1142,6 +1153,158 @@ function requiresOf7(stmt) {
     }
     return out;
 }
+/** CommonJS require bindings split into a declaration and one later
+ * assignment (`var m; m = require("./x")`): a top-level `var` or `let`
+ * declaration without initializer in a CommonJS file, assigned by exactly one
+ * top-level `m = require("<literal>")` statement of the require global over
+ * a compiled program module, and written nowhere else. The binding holds the
+ * module's exports from the assignment on, as `const m = require("./x")`
+ * does, so preflight treats the assignment as that require: its module edge,
+ * its cycle admission and its early-read fence. The lowering's recognizer
+ * (splitRequireBindingOf in cjs-inline-require.ts) accepts only these
+ * bindings. Keyed by declaration, with the assignment's require call. */
+function splitRequireBindings7(program, sf) {
+    const memo = program.analysis.splitRequireBindings;
+    const cached = memo.get(sf);
+    if (cached !== undefined)
+        return cached;
+    const out = new Map();
+    memo.set(sf, out);
+    if (sf.isDeclarationFile || !isCjsJsFile7(sf, program) || !sf.text.includes("require"))
+        return out;
+    const checker = program.getTypeChecker();
+    const stmts = sf.statements.nodes;
+    const candidates = new Map();
+    for (const stmt of stmts) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        if ((stmt.declarationList.flags & (ts.NodeFlags.Const | ts.NodeFlags.Using)) !== 0)
+            continue;
+        for (const decl of stmt.declarationList.declarations.nodes) {
+            if (!ts.isIdentifier(decl.name) || decl.initializer !== undefined)
+                continue;
+            const symbol = checker.getSymbolAtLocation(decl.name);
+            if (symbol === undefined || symbol.declarations.length !== 1)
+                continue;
+            candidates.set(symbol, { decl, call: null, assigns: 0 });
+        }
+    }
+    if (candidates.size === 0)
+        return out;
+    // The one top-level `m = ...` statement, whose right side is the require.
+    for (const stmt of stmts) {
+        if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
+            continue;
+        const assign = stmt.expression;
+        if (assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isIdentifier(assign.left))
+            continue;
+        const symbol = checker.getSymbolAtLocation(assign.left);
+        const candidate = symbol !== undefined ? candidates.get(symbol) : undefined;
+        if (candidate === undefined)
+            continue;
+        candidate.assigns++;
+        let right = assign.right;
+        while (ts.isParenthesizedExpression(right))
+            right = right.expression;
+        if (ts.isCallExpression(right) && splitRequireTarget7(program, sf, right))
+            candidate.call = right;
+    }
+    const names = new Set();
+    for (const candidate of candidates.values()) {
+        if (candidate.assigns === 1 && candidate.call !== null)
+            names.add(candidate.decl.name.text);
+    }
+    if (names.size === 0)
+        return out;
+    // Exactly one write in the whole file: the assignment itself.
+    const writes = new Map();
+    ts.walkPreorder(sf, (node) => {
+        if (!ts.isIdentifier(node) || !names.has(node.text))
+            return undefined;
+        const parent = node.parent;
+        const symbol = parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === node
+            ? (checker.getShorthandAssignmentValueSymbol(parent) ?? checker.getSymbolAtLocation(node))
+            : checker.getSymbolAtLocation(node);
+        if (symbol === undefined || !candidates.has(symbol) || !isWriteReference7(node))
+            return undefined;
+        writes.set(symbol, (writes.get(symbol) ?? 0) + 1);
+        return undefined;
+    });
+    for (const [symbol, candidate] of candidates) {
+        if (candidate.assigns === 1 && candidate.call !== null && writes.get(symbol) === 1)
+            out.set(candidate.decl, candidate.call);
+    }
+    return out;
+}
+/** True when `call` is a require of the CommonJS global over a compiled
+ * program module: not a builtin, a JSON document or a declaration file. */
+function splitRequireTarget7(program, sf, call) {
+    const spec = requireSpecOf7(call);
+    if (spec === null || canonicalBuiltinModule(spec) !== null)
+        return false;
+    if (requireCallBindingKind7(program, call) !== "ambient")
+        return false;
+    const dep = resolveImport7(program, sf, spec, "require") ?? npmStaticDepSf7(program, sf, spec, "require");
+    return dep !== null && !dep.isDeclarationFile && !dep.fileName.endsWith(".json");
+}
+/** The split require binding a top-level statement assigns, or null. */
+function splitRequireOfStatement7(program, stmt) {
+    if (!ts.isExpressionStatement(stmt) ||
+        !ts.isBinaryExpression(stmt.expression) ||
+        !ts.isSourceFile(stmt.parent))
+        return null;
+    let right = stmt.expression.right;
+    while (ts.isParenthesizedExpression(right))
+        right = right.expression;
+    for (const [decl, call] of splitRequireBindings7(program, stmt.parent))
+        if (call === right)
+            return { decl, call };
+    return null;
+}
+/** The top-level statement of a split require binding's assignment, from
+ * its require call (`m = require("./x")` or `m = (require("./x"))`). */
+function splitRequireStatementOf7(call) {
+    let node = call;
+    while (node.parent !== undefined && ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    return node.parent?.parent;
+}
+/** The require call of a split require binding's declaration, or null. */
+function splitRequireCallOf7(program, decl) {
+    return splitRequireBindings7(program, ts.getSourceFileOfNode(decl)).get(decl) ?? null;
+}
+/** True when `id` is written: an assignment target (compound and
+ * destructuring included), an update operand, or a for-in/of target. */
+function isWriteReference7(id) {
+    let n = id;
+    for (;;) {
+        const p = n.parent;
+        if (p === undefined)
+            return false;
+        if (ts.isBinaryExpression(p)) {
+            const k = p.operatorToken.kind;
+            return (p.left === n && k >= ts.SyntaxKind.FirstAssignment && k <= ts.SyntaxKind.LastAssignment);
+        }
+        if (ts.isPostfixUnaryExpression(p) || ts.isPrefixUnaryExpression(p)) {
+            return ((p.operator === ts.SyntaxKind.PlusPlusToken ||
+                p.operator === ts.SyntaxKind.MinusMinusToken) &&
+                p.operand === n);
+        }
+        if (ts.isForOfStatement(p) || ts.isForInStatement(p))
+            return p.initializer === n;
+        if (ts.isParenthesizedExpression(p) ||
+            ts.isArrayLiteralExpression(p) ||
+            ts.isSpreadElement(p) ||
+            ts.isSpreadAssignment(p) ||
+            ts.isShorthandPropertyAssignment(p) ||
+            ts.isObjectLiteralExpression(p) ||
+            (ts.isPropertyAssignment(p) && p.initializer === n)) {
+            n = p;
+            continue;
+        }
+        return false;
+    }
+}
 /** `true`, or `!0`, its minified spelling. */
 function isTrueLiteral(expr) {
     return (expr.kind === ts.SyntaxKind.TrueKeyword ||
@@ -1269,7 +1432,7 @@ function purePrefixStmt7(program, s) {
         return true;
     if (ts.isExpressionStatement(s) && ts.isStringLiteral(s.expression))
         return true; // directive
-    if (isRequireStatement7(s))
+    if (isRequireStatement7(s) || splitRequireOfStatement7(program, s) !== null)
         return true;
     if (isCjsJsFile7(ts.getSourceFileOfNode(s), program)) {
         if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
@@ -1393,12 +1556,18 @@ function requireEarlyReference7(program, decl) {
     if (cached !== undefined)
         return cached;
     let found = null;
-    const stmt = decl.parent?.parent;
     const sf = ts.getSourceFileOfNode(decl);
-    if (stmt !== undefined && ts.isVariableStatement(stmt) && ts.isSourceFile(stmt.parent)) {
+    // A split require binding is bound at its assignment statement.
+    const splitCall = splitRequireCallOf7(program, decl);
+    const stmt = splitCall !== null ? splitRequireStatementOf7(splitCall) : decl.parent?.parent;
+    if (stmt !== undefined &&
+        (ts.isVariableStatement(stmt) || splitCall !== null) &&
+        ts.isSourceFile(stmt.parent)) {
         const stmts = sf.statements.nodes;
         const k = stmts.indexOf(stmt);
-        const declarations = stmt.declarationList.declarations.nodes;
+        const declarations = ts.isVariableStatement(stmt)
+            ? stmt.declarationList.declarations.nodes
+            : [];
         // Earlier declarators run too: `const x = read(), dep = require('./dep')`.
         const precedingDecls = declarations.slice(0, declarations.indexOf(decl));
         let firstRunnable = program.analysis.requireFirstRunnable.get(sf);
@@ -1446,6 +1615,12 @@ exactEarlyRead) {
     }
     if (bindings.size === 0)
         return null;
+    // A split require binding's assignment writes the binding; it reads nothing.
+    let splitWrite = splitRequireCallOf7(program, decl);
+    while (splitWrite !== null && ts.isParenthesizedExpression(splitWrite.parent))
+        splitWrite = splitWrite.parent;
+    splitWrite =
+        splitWrite !== null && ts.isBinaryExpression(splitWrite.parent) ? splitWrite.parent.left : null;
     const stmts = sf.statements.nodes;
     const cjs = isCjsJsFile7(sf, program);
     const symbolOf = (id) => {
@@ -1690,7 +1865,7 @@ exactEarlyRead) {
             if (sym === undefined)
                 return undefined;
             if (bindings.has(sym)) {
-                if (exactEarlyRead?.(n) === true)
+                if (n === splitWrite || exactEarlyRead?.(n) === true)
                     return undefined;
                 hit = n;
                 return "stop";
@@ -3091,7 +3266,7 @@ function cjsCycleRefusal7(program, comp, lineOf) {
         }
         // Bindings of other members must stay unreachable from top-level code.
         for (const st of stmts) {
-            for (const req of requiresOf7(st)) {
+            for (const req of requiresOf7(st, program)) {
                 if (req.decl === null)
                     continue;
                 const dep = resolveImport7(program, m, req.spec, "require");
@@ -5221,17 +5396,20 @@ function preflight7(load) {
                 const early = req.decl !== null ? requireEarlyReference7(program, req.decl) : null;
                 if (early === null ||
                     (bindingKind !== "createRequire" &&
+                        req.split === undefined &&
                         ((req.decl.parent?.flags ?? 0) & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0)) {
                     return false;
                 }
                 diags.push(unsupportedDiag("SC1013", loc, bindingKind === "createRequire"
                     ? `createRequire() binding '${early.text}' below code that can reach it (Node throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`
-                    : `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`));
+                    : req.split !== undefined
+                        ? `require() binding '${early.text}' assigned below code that can reach it (Node reads undefined before the assignment runs, which is not modeled — move the assignment above the code that can run first)`
+                        : `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`));
                 return true;
             };
             for (let k = 0; k < stmts.length; k++) {
                 const stmt = stmts[k];
-                for (const req of requiresOf7(stmt)) {
+                for (const req of requiresOf7(stmt, program)) {
                     const loc = {
                         file: sf.fileName,
                         start: ts.tokenStartOfNode(req.node),
@@ -5260,8 +5438,8 @@ function preflight7(load) {
                     if (jsonDep !== null && jsonDep.fileName.endsWith(".json")) {
                         if (bindingKind === "createRequire")
                             continue;
-                        if (ts.isVariableStatement(stmt) && requiresOf7(stmt).length > 1) {
-                            const others = requiresOf7(stmt).some((r) => {
+                        if (ts.isVariableStatement(stmt) && requiresOf7(stmt, program).length > 1) {
+                            const others = requiresOf7(stmt, program).some((r) => {
                                 const d = resolveImport7(program, sf, r.spec, "require");
                                 return d === null || !d.fileName.endsWith(".json");
                             });
@@ -5423,9 +5601,14 @@ function preflight7(load) {
             // counts, and targets outside the compiled graph add nothing here:
             // their use sites keep their existing lowering fences.
             if (jsRequireFile && !isNodeEsmFile7(sf, program)) {
+                // A split require binding's assignment is a statement-level require
+                // edge (requiresOf7 above), parenthesized or not.
+                const splitCalls = new Set(splitRequireBindings7(program, sf).values());
                 for (const call of inlineRequiresOf7(sf)) {
                     if (requireCallBindingKind7(program, call) !== "ambient")
                         continue;
+                    if (splitCalls.has(call))
+                        continue;
                     const spec = requireSpecOf7(call);
                     if (load.externalTypes.has(spec) || canonicalBuiltinModule(spec) !== null)
                         continue;
@@ -5798,7 +5981,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
         const nextSeen = new Set(seenModules);
         nextSeen.add(dep);
         const module = checker.getSymbolAtLocation(dep);
-        const exported = module?.getExports().get(name);
+        const exported = module?.getExports().get(ts.escapedSymbolName(name));
         if (exported !== undefined) {
             let resolved = exported;
             const seenSymbols = new Set();
@@ -6076,7 +6259,7 @@ const nodeBuiltinNames = new Set(builtinModules);
 export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
 export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
 export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
-export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
+export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
 /** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
  * types come entirely from inference (checkJs + JSDoc) and whose classes
  * declare fields by constructor assignment. */