@scriptc/compiler 0.4.4 → 0.4.5

package/dist/frontend/program.d.ts

@@ -305,6 +305,21 @@ export declare function checkPreflightTs7(entryPath: string, host: ts.Ts7Host):
     diags: ScrDiagnostic[];
     moduleOrder: string[];
 };
+/** The property names of Node's namespace object for the CommonJS module
+ * `dep`: the names its lexer detects, CommonJS re-exports included (the
+ * rule of the named-import link check), plus `default` and
+ * `module.exports`. */
+/** `dep` and every CommonJS module it re-exports, transitively (the modules
+ * whose exports its namespace object shows). */
+export declare function cjsReexportedModules(program: ts.Program, dep: ts.SourceFile): ts.SourceFile[];
+export declare function cjsNamespaceExportNames(program: ts.Program, dep: ts.SourceFile): Set<string>;
+/** The export names a CommonJS module assigns inside functions
+ * (`exports.current = value` in a function body), or "all" when such code
+ * writes a computed name, replaces module.exports or redefines exports
+ * through Object.defineProperty. Node's namespace object of the module
+ * holds the values the exports had when the module finished evaluating,
+ * so it does not see those writes. */
+export declare function cjsExportsAssignedInFunctions(sf: ts.SourceFile): ReadonlySet<string> | "all";
 export declare function esmNamedImportLinkCrash(program: ts.Program, entry: ts.SourceFile): StartupCrash | null;
 export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
 export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";

package/dist/frontend/program.js

@@ -49,7 +49,7 @@ import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.
 import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js";
 import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties, } from "./npm-static-declaration-syntax.js";
-import { configurePackageShims, isPackageShimFile, isPackageShimName, isShimmedImport, } from "./package-shims.js";
+import { configurePackageShims, isPackageShimFile, isShimmedImport, npmStaticOmitsPackage, } from "./package-shims.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
 import { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
@@ -62,6 +62,7 @@ import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
 import { planDeclProjection } from "./decl-projection.js";
+import { reportShapes } from "./shape-inference/index.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
@@ -303,33 +304,31 @@ function visitNpmStaticDeclarationClosure(services, entryPath, onSource) {
     };
     visit(entryPath);
 }
-function npmStaticDeclarationOverloadsOf(services, entryPath) {
-    const classes = new Map();
+/** The overloads and properties of the classes a package's declaration
+ * closure declares, read from one parse of each declaration file. */
+function npmStaticDeclarationMetadataOf(services, entryPath) {
+    const overloads = new Map();
+    const properties = new Map();
     visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
-        for (const [className, methods] of parseNpmStaticDeclarationOverloads(services.parse(path, source, "ts"))) {
-            const target = classes.get(className) ?? new Map();
-            classes.set(className, target);
+        const sourceFile = services.parse(path, source, "ts");
+        for (const [className, methods] of parseNpmStaticDeclarationOverloads(sourceFile)) {
+            const target = overloads.get(className) ?? new Map();
+            overloads.set(className, target);
             for (const [methodName, signatures] of methods) {
                 if (!target.has(methodName))
                     target.set(methodName, signatures);
             }
         }
-    });
-    return classes;
-}
-function npmStaticDeclarationPropertiesOf(services, entryPath) {
-    const classes = new Map();
-    visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
-        for (const [className, properties] of parseNpmStaticDeclarationProperties(services.parse(path, source, "ts"))) {
-            const target = classes.get(className) ?? new Map();
-            classes.set(className, target);
-            for (const [propertyName, type] of properties) {
+        for (const [className, fields] of parseNpmStaticDeclarationProperties(sourceFile)) {
+            const target = properties.get(className) ?? new Map();
+            properties.set(className, target);
+            for (const [propertyName, type] of fields) {
                 if (!target.has(propertyName))
                     target.set(propertyName, type);
             }
         }
     });
-    return classes;
+    return { overloads, properties };
 }
 /** True when a coverage mapping names one exact bare host module. TypeScript
  * gives `paths` keys containing `*` pattern semantics, so accepting one here
@@ -808,11 +807,12 @@ export function loadProgram(entryPath, services, opts) {
         }
         externalTypes.set(specifier, declarationPath);
     }
-    // Packages scriptc implements itself or the project marks never loaded
-    // (package-shims.ts) never compile their published JavaScript, even when
-    // named.
+    // Packages scriptc implements itself, and packages the project marks
+    // never loaded (package-shims.ts), never compile their published
+    // JavaScript, even when named. A registry entry's `sourceVersions`
+    // (chalk 6) compile from their own source.
     configurePackageShims(entryPath);
-    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !isPackageShimName(name));
+    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !npmStaticOmitsPackage(entryPath, name));
     // Resolve authored declaration entries before enabling the JS-only
     // package resolver. Safe overload metadata binds through the runtime
     // entry to one exact implementation file; it never contributes values
@@ -827,8 +827,7 @@ export function loadProgram(entryPath, services, opts) {
             !/\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile)) {
             continue;
         }
-        const overloads = npmStaticDeclarationOverloadsOf(services, resolved.typesFile);
-        const properties = npmStaticDeclarationPropertiesOf(services, resolved.typesFile);
+        const { overloads, properties } = npmStaticDeclarationMetadataOf(services, resolved.typesFile);
         const classNames = new Set([...overloads.keys(), ...properties.keys()]);
         if (classNames.size === 0)
             continue;
@@ -976,6 +975,10 @@ export function loadProgram(entryPath, services, opts) {
         };
     try {
         const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector);
+        // Shape inference, stage S1: a report only (SCRIPTC_DEBUG_SHAPES).
+        const shapes = process.env["SCRIPTC_DEBUG_SHAPES"];
+        if (shapes !== undefined && shapes !== "" && shapes !== "0" && npmStaticPackages.length > 0)
+            reportShapes(load.program, shapes);
         return {
             ...load,
             services,
@@ -1013,9 +1016,9 @@ export function loadProgram(entryPath, services, opts) {
  * packages whose declarations the boundary projects from. */
 function declBoundaryUserFiles(program, packages) {
     const out = [];
-    for (const sf of program.getSourceFiles()) {
+    for (const sf of program.getImplementationSourceFiles()) {
         const name = sf.fileName.split("\\").join("/");
-        if (sf.isDeclarationFile || name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
+        if (name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
             continue;
         if (name.endsWith(".tsx"))
             continue; // JSX files: not projected yet
@@ -1088,9 +1091,14 @@ function suppressedJsStrictness7(d) {
         return ts.flattenDiagnosticMessageText(d, "\n").includes("'any'");
     }
     // The deprecated Buffer(...) call without `new`, which Node's Buffer
-    // function accepts (containers/bytes.ts lowers it).
+    // function accepts (containers/bytes.ts lowers it), and fs.ReadStream(...)
+    // and fs.WriteStream(...), which construct their stream
+    // (builtins/fs-streams.ts).
     if (d.code === 2348) {
-        return ts.flattenDiagnosticMessageText(d, "\n").includes("'BufferConstructor'");
+        const text = ts.flattenDiagnosticMessageText(d, "\n");
+        return (text.includes("'BufferConstructor'") ||
+            text.includes("'typeof ReadStream'") ||
+            text.includes("'typeof WriteStream'"));
     }
     return false;
 }
@@ -2198,18 +2206,30 @@ export function isCreateRequireBinding7(program, callee) {
         ((decl.parent.flags & ts.NodeFlags.Const) !== 0 ||
             stableCreateRequireBindingReason7(program, decl) === null));
 }
-/** Only literal calls and literal resolution queries can erase the loader
- * value. In particular, assignments, exported aliases, shorthand properties,
- * optional calls, and passing the loader to user code cannot pass this test. */
-function staticCreateRequireUse7(expr) {
+/** How a use of a createRequire loader lowers:
+ * - "static": a literal call or a literal resolution query, which erases
+ *   the loader value.
+ * - "deferred": a call with a computed specifier or another argument shape,
+ *   or `resolve` / `resolve.paths` read as a value, inside the try block
+ *   of a try statement in the same function. The call throws a runtime
+ *   fence, and the resolve value is a function that throws one when called
+ *   (module-resolution.ts), so the statement's catch clause handles them
+ *   (packages that look for optional native addons).
+ * - "computed": the same shapes outside a try block.
+ * - "escaping": the loader itself as a value, writes, optional calls, and
+ *   other members. */
+const COMPUTED_CREATE_REQUIRE_REASON = "its createRequire result is used with a computed specifier, or its resolve as a value, outside a try block (static requires need literal specifiers)";
+function createRequireUse7(expr) {
     let use = expr;
     while (ts.isParenthesizedExpression(use.parent))
         use = use.parent;
+    let member = false;
     if (ts.isPropertyAccessExpression(use.parent) &&
         use.parent.expression === use &&
         use.parent.name.text === "resolve" &&
         !use.parent.questionDotToken) {
         use = use.parent;
+        member = true;
         if (ts.isPropertyAccessExpression(use.parent) &&
             use.parent.expression === use &&
             use.parent.name.text === "paths" &&
@@ -2217,11 +2237,37 @@ function staticCreateRequireUse7(expr) {
             use = use.parent;
     }
     const call = use.parent;
-    return (ts.isCallExpression(call) &&
-        call.expression === use &&
-        !call.questionDotToken &&
-        call.arguments.nodes.length === 1 &&
-        ts.isStringLiteralLike(call.arguments.nodes[0]));
+    if (ts.isCallExpression(call) && call.expression === use) {
+        if (call.questionDotToken)
+            return "escaping";
+        if (call.arguments.nodes.length === 1 && ts.isStringLiteralLike(call.arguments.nodes[0]))
+            return "static";
+    }
+    else if (!member || isAssignmentTarget7(use)) {
+        return "escaping";
+    }
+    return insideTryBlock7(use) ? "deferred" : "computed";
+}
+function isAssignmentTarget7(node) {
+    const parent = node.parent;
+    return (ts.isBinaryExpression(parent) &&
+        parent.left === node &&
+        parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+}
+/** True when `node` is inside the try block of a try statement in the same
+ * function (a catch clause or finally block does not count). A class field
+ * initializer runs when the class is instantiated, so it is a boundary too. */
+function insideTryBlock7(node) {
+    for (let child = node, parent = node.parent; parent; child = parent, parent = parent.parent) {
+        if (ts.isTryStatement(parent) && parent.tryBlock === child)
+            return true;
+        if (ts.isFunctionLike(parent) ||
+            ts.isClassStaticBlockDeclaration(parent) ||
+            ts.isPropertyDeclaration(parent))
+            return false;
+    }
+    return false;
 }
 function stableCreateRequireBindingReason7(program, decl) {
     const cache = program.analysis.createRequireReasons;
@@ -2252,9 +2298,13 @@ function stableCreateRequireBindingReason7(program, decl) {
                 : checker.getSymbolAtLocation(ref);
             if (target && (target.flags & ts.SymbolFlags.Alias) !== 0)
                 target = checker.getAliasedSymbol(target);
-            if (target === symbol && !staticCreateRequireUse7(ref)) {
-                return "its createRequire binding is reassigned, escapes, or uses a computed specifier";
-            }
+            if (target !== symbol)
+                continue;
+            const use = createRequireUse7(ref);
+            if (use === "computed")
+                return COMPUTED_CREATE_REQUIRE_REASON;
+            if (use === "escaping")
+                return "its createRequire binding is reassigned or escapes";
         }
         const preceding = stmt.declarationList.declarations.nodes.slice(0, stmt.declarationList.declarations.nodes.indexOf(decl));
         if (bindingEarlyUse7(program, sf, sf.statements.nodes.indexOf(stmt), decl, preceding) !== null) {
@@ -2308,10 +2358,11 @@ function npmStaticModuleImportReason7(program, stmt) {
         checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, specifier.name.text));
         let reason = null;
         const checkUse = (expr) => {
-            if (!staticCreateRequireUse7(expr)) {
-                reason =
-                    "its createRequire result escapes or is used with a computed specifier (static requires need literal specifiers)";
-            }
+            const use = createRequireUse7(expr);
+            if (use === "computed")
+                reason = COMPUTED_CREATE_REQUIRE_REASON;
+            else if (use === "escaping")
+                reason = "its createRequire result escapes (static requires need literal specifiers)";
         };
         ts.walkPreorder(sf, (node) => {
             if (reason ||
@@ -3489,9 +3540,13 @@ function exactCycleRefusal7(program, comp, lineOf) {
             if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
                 return `the default export expression at ${lineOf(stmt)} has no initialization state inside the cycle`;
             }
+            // `export * from` binds each name to the declaring member's own
+            // binding, like a named re-export, so only `export * as ns` (a
+            // namespace object of a member) has state of its own.
             if (ts.isExportDeclaration(stmt) &&
                 !stmt.isTypeOnly &&
-                (stmt.exportClause === undefined || ts.isNamespaceExport(stmt.exportClause))) {
+                stmt.exportClause !== undefined &&
+                ts.isNamespaceExport(stmt.exportClause)) {
                 const dep = targetOf(stmt);
                 if (dep !== null && members.has(dep)) {
                     return `the namespace re-export at ${lineOf(stmt)} names a module of the cycle`;
@@ -4876,6 +4931,15 @@ function preflight7(load) {
             return false;
         return new RegExp(`\\btypeof\\s*\\(?\\s*${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(sf.text);
     };
+    // A `return` at the top level of a CommonJS module (TS1108): Node runs
+    // the module as a function body, so the return ends the module's
+    // evaluation. ES modules and TypeScript keep the error.
+    const cjsTopLevelReturnSuppressed = (p, d) => {
+        if (d.code !== 1108 || d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        return sf !== undefined && isCjsJsFile7(sf, p);
+    };
     const workspaceImplicitAnySuppressed = (p, d) => {
         if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
             return false;
@@ -4923,6 +4987,7 @@ function preflight7(load) {
             !isNpmStaticSubclassArgument(p, d) &&
             !workspaceImplicitAnySuppressed(p, d) &&
             !typeofTestedNameSuppressed(p, d) &&
+            !cjsTopLevelReturnSuppressed(p, d) &&
             !jsdocTypeSuppressed(p, d, commentDup));
     };
     // The tsc gate, with a second chance: the LOWERING world's checker
@@ -5366,9 +5431,13 @@ function preflight7(load) {
                         // to Node's no-op, the module still evaluates through its
                         // ordinary init edge, and no member is ever read through the
                         // lexer facade (self-imports of a CJS module included — the
-                        // partially-built exports are never observed). Any OTHER use
-                        // keeps the fence.
-                        if (!nsBindingUsesAreBareStatements7(program, sf, clause.namedBindings.name)) {
+                        // partially-built exports are never observed). In JavaScript
+                        // sources every use passes here: member reads lower through the
+                        // names Node's lexer detects, and the other reads refuse at
+                        // their site (lower-namespaces.ts, cjsNamespaceImportDep). Any
+                        // OTHER use in TypeScript keeps the fence.
+                        if (!isJsSourceFileName(sf.fileName) &&
+                            !nsBindingUsesAreBareStatements7(program, sf, clause.namedBindings.name)) {
                             diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings), "namespace imports of CommonJS modules"));
                         }
                     }
@@ -5759,6 +5828,111 @@ function preflight7(load) {
         moduleEdges: edges,
     };
 }
+/* ── the CJS named-import link check ─────────────────────────────────────
+ * Node builds a CommonJS module's ESM facade from its LEXER (cjs-lexer.ts
+ * mirrors it), never from execution — so a named import the checker binds
+ * happily can still fail Node's instantiate phase with a SyntaxError,
+ * thrown before ANY module in the graph evaluates. The checker's word is
+ * NOT Node's word exactly here, and shipping the checker's answer would
+ * diverge from Node without a diagnostic (`module.exports = { a: 7 }` served `a` where
+ * Node refuses the program). This walk asks Node's question at compile
+ * time, in Node's exact ORDER, and answers with Node's exact message. */
+/** The CommonJS program file a re-export (`module.exports = require(spec)`)
+ * of `from` resolves to, or null: reexport targets union in only when they
+ * resolve to CommonJS program files (Node's cjsPreparseModuleExports rule). */
+function cjsReexportDep7(program) {
+    return (from, spec) => {
+        const dep = resolveImport7(program, from, spec, "require") ??
+            npmStaticDepSf7(program, from, spec, "require");
+        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
+    };
+}
+/** Node's lexer analysis of a CommonJS file. A bundler rewrite spells some
+ * lexer-visible names as accessors. */
+function lexWithAccessorNames(sf) {
+    const lexed = cjsLexedExportsOfFile(sf);
+    for (const name of npmStaticLexerVisibleNames(sf.fileName))
+        lexed.exports.add(name);
+    return lexed;
+}
+/** The property names of Node's namespace object for the CommonJS module
+ * `dep`: the names its lexer detects, CommonJS re-exports included (the
+ * rule of the named-import link check), plus `default` and
+ * `module.exports`. */
+/** `dep` and every CommonJS module it re-exports, transitively (the modules
+ * whose exports its namespace object shows). */
+export function cjsReexportedModules(program, dep) {
+    const resolveDep = cjsReexportDep7(program);
+    const seen = new Set([dep]);
+    const order = [dep];
+    for (let i = 0; i < order.length; i++) {
+        const mod = order[i];
+        for (const spec of lexWithAccessorNames(mod).reexports) {
+            const next = resolveDep(mod, spec);
+            if (next !== null && !seen.has(next)) {
+                seen.add(next);
+                order.push(next);
+            }
+        }
+    }
+    return order;
+}
+export function cjsNamespaceExportNames(program, dep) {
+    const names = cjsVisibleNames(dep, lexWithAccessorNames, cjsReexportDep7(program), new Map());
+    return new Set([...names, "default", "module.exports"]);
+}
+/** The export names a CommonJS module assigns inside functions
+ * (`exports.current = value` in a function body), or "all" when such code
+ * writes a computed name, replaces module.exports or redefines exports
+ * through Object.defineProperty. Node's namespace object of the module
+ * holds the values the exports had when the module finished evaluating,
+ * so it does not see those writes. */
+export function cjsExportsAssignedInFunctions(sf) {
+    const names = new Set();
+    let all = false;
+    const exportsObject = (e) => (ts.isIdentifier(e) && e.text === "exports") || isModuleExportsAccess(e);
+    const target = (e) => {
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (isModuleExportsAccess(e))
+            all = true;
+        else if (ts.isPropertyAccessExpression(e) && exportsObject(e.expression))
+            names.add(e.name.text);
+        else if (ts.isElementAccessExpression(e) && exportsObject(e.expression)) {
+            if (ts.isStringLiteralLike(e.argumentExpression))
+                names.add(e.argumentExpression.text);
+            else
+                all = true;
+        }
+    };
+    const visit = (node, inFunction) => {
+        if (all)
+            return;
+        const nested = inFunction || ts.isFunctionLike(node);
+        if (nested) {
+            if (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+                target(node.left);
+            else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken))
+                target(node.operand);
+            else if (ts.isDeleteExpression(node))
+                target(node.expression);
+            else if (ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isIdentifier(node.expression.expression) &&
+                node.expression.expression.text === "Object" &&
+                node.arguments.nodes[0] !== undefined &&
+                exportsObject(node.arguments.nodes[0]))
+                all = true;
+        }
+        ts.forEachChild(node, (child) => visit(child, nested));
+    };
+    visit(sf, false);
+    return all ? "all" : names;
+}
 /** Walks the entry's ESM instantiate graph exactly as V8 does — children
  * in request order, each module's own imports checked AFTER its children
  * (postorder), regular imports sorted by LOCAL name (code units), then
@@ -5784,25 +5958,14 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         const npmStatic = npmStaticDepSf7(program, from, spec);
         return npmStatic;
     };
-    // Reexport targets union in only when they resolve to CommonJS program
-    // files (Node's cjsPreparseModuleExports rule).
-    const resolveCjsDep = (from, spec) => {
-        const dep = resolveImport7(program, from, spec, "require") ??
-            npmStaticDepSf7(program, from, spec, "require");
-        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
-    };
-    // A bundler rewrite spells some lexer-visible names as accessors.
-    const lexWithAccessorNames = (sf) => {
-        const lexed = cjsLexedExportsOfFile(sf);
-        for (const name of npmStaticLexerVisibleNames(sf.fileName))
-            lexed.exports.add(name);
-        return lexed;
-    };
+    const resolveCjsDep = cjsReexportDep7(program);
     const visible = (dep, name) => 
-    // `default` is the module.exports binding itself — always provided.
-    // The program already owns native source ASTs; reuse them without
-    // starting another syntax session or reparsing their source text.
+    // `default` and `module.exports` are the module.exports binding itself
+    // — always provided. The program already owns native source ASTs;
+    // reuse them without starting another syntax session or reparsing
+    // their source text.
     name === "default" ||
+        name === "module.exports" ||
         cjsVisibleNames(dep, lexWithAccessorNames, resolveCjsDep, lexMemo).has(name);
     /** The statement's resolved LOCAL CommonJS dependency, when it is an
      * import/re-export from one. */