@scriptc/compiler 0.1.3 → 0.1.4

package/dist/frontend/program.js

@@ -53,6 +53,7 @@ import { builtinDefaultImportModule, canonicalBuiltinModule, SUPPORTED_NODE_MODU
 import { clearWorkspacePackages, isRelativeSpecifier, isWorkspacePackageName, npmPackageNameOf, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.js";
 import { ADOPTED_OPTIONS, isJsSourceFileName, JS_ANY_OPERATOR_CODES, JS_RELAXED_TSC_CODES, } from "./tsc-codes.js";
 import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
+import { forkTargetPaths } from "./fork-target.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -344,6 +345,44 @@ function externalTypeFileClosure7(program, externalTypes) {
     }
     return new Map([...ownersByFile].map(([file, owners]) => [file, [...owners]]));
 }
+/** Program roots hidden behind canonical createRequire bindings. tsgo
+ * discovers ordinary import/require edges itself, but a source binding
+ * returned by createRequire is intentionally just a function to the type
+ * checker. Rebuild the native program with each literal project target as
+ * an explicit root, to a fixpoint, so the same TS 7 AST/checker world owns
+ * their exports and transitive graph. */
+function createRequireProgramRoots7(program) {
+    const known = new Set(program.getSourceFiles().map((sf) => tsgoPath(resolve(sf.fileName))));
+    const roots = new Set();
+    for (const sf of program.getSourceFiles()) {
+        if (sf.isDeclarationFile || sf.fileName.endsWith(".json"))
+            continue;
+        ts.walkPreorder(sf, (node) => {
+            if (!ts.isCallExpression(node) || node.questionDotToken !== undefined ||
+                node.arguments.length !== 1 || !ts.isStringLiteralLike(node.arguments[0]) ||
+                !ts.isIdentifier(node.expression) || !isCreateRequireBinding7(program, node.expression)) {
+                return undefined;
+            }
+            const spec = node.arguments[0].text;
+            if (canonicalBuiltinModule(spec) !== null)
+                return "skip";
+            let target = resolveProjectModule(sf.fileName, spec);
+            if (target === null && !spec.startsWith("#")) {
+                const npm = resolveNpmImport7(sf.fileName, spec);
+                if (npm !== null && isNpmStaticPackage(npm.packageName) && isJsSourceFileName(npm.typesFile)) {
+                    target = npm.typesFile;
+                }
+            }
+            if (target === null || target.endsWith(".json"))
+                return "skip";
+            const normalized = tsgoPath(resolve(target));
+            if (!known.has(normalized))
+                roots.add(normalized);
+            return "skip";
+        });
+    }
+    return [...roots].sort();
+}
 function loadProgram7(host, entryPath, externalTypes = new Map()) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
@@ -379,7 +418,22 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
         options = { ...options, paths };
     }
     const coreRoots = [entryPath, ambientDtsPath(), nodeTypes ?? fallbackDtsPath()];
-    const program = ts.createProgram([...coreRoots, overridesDtsPath()], options, host);
+    const programRoots = [...coreRoots];
+    let program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
+    for (let pass = 0; pass < 32; pass++) {
+        const candidates = [
+            ...createRequireProgramRoots7(program),
+            ...forkTargetPaths(program, program.getSourceFiles()),
+        ];
+        const extraRoots = candidates.filter((root, index) => !programRoots.includes(root) && candidates.indexOf(root) === index);
+        if (extraRoots.length === 0)
+            break;
+        program.dispose();
+        programRoots.push(...extraRoots);
+        program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
+        if (pass === 31)
+            throw new Error("static program-root discovery did not converge");
+    }
     const entry = program.getSourceFile(entryPath);
     if (!entry)
         throw new Error(`could not load ${entryPath}`);
@@ -392,7 +446,7 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
         configDiags: config.diags,
         externalTypes,
         externalTypeSpecifiersByFile,
-        projectWorld: () => (projectWorld ??= ts.createProgram(coreRoots, options, host)),
+        projectWorld: () => (projectWorld ??= ts.createProgram(programRoots, options, host)),
         disposeAll: () => {
             projectWorld?.dispose();
             program.dispose();
@@ -562,13 +616,18 @@ function suppressedJsStrictness7(d) {
  * share — anything require-shaped it does NOT match (computed specifiers,
  * extra arguments) is not a module edge and fences at its use site. */
 function requireSpecOf7(node) {
-    if (!ts.isCallExpression(node))
+    let value = node;
+    while (ts.isParenthesizedExpression(value) || ts.isAsExpression(value) ||
+        ts.isTypeAssertion(value) || ts.isNonNullExpression(value)) {
+        value = value.expression;
+    }
+    if (!ts.isCallExpression(value))
         return null;
-    if (!ts.isIdentifier(node.expression) || node.expression.text !== "require")
+    if (!ts.isIdentifier(value.expression) || value.expression.text !== "require")
         return null;
-    if (node.arguments.length !== 1)
+    if (value.arguments.length !== 1)
         return null;
-    const arg = node.arguments[0];
+    const arg = value.arguments[0];
     return ts.isStringLiteral(arg) ? arg.text : null;
 }
 /** True for statements that are CommonJS require IMPORTS at a module's top
@@ -806,7 +865,8 @@ function isCreateRequireBinding7(program, callee) {
  * module edges; other source bindings get a pointed fence before lowering
  * can mistake them for module syntax. */
 function requireCallBindingKind7(program, node) {
-    const call = ts.isVariableDeclaration(node) ? node.initializer : node;
+    const raw = ts.isVariableDeclaration(node) ? node.initializer : node;
+    const call = raw && ts.isExpression(raw) ? stripRequireCasts7(raw) : raw;
     if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
         return "ambient";
     const checker = program.getTypeChecker();
@@ -2234,7 +2294,8 @@ function preflight7(load) {
                 depPositions.get(sf).push({ dep, pos: stmt.getStart(sf) });
             }
         }
-        if (isJsSourceFileName(sf.fileName)) {
+        {
+            const jsRequireFile = isJsSourceFileName(sf.fileName);
             const stmts = sf.statements;
             let firstRunnable = -1;
             stmts.forEach((s, i) => {
@@ -2245,8 +2306,14 @@ function preflight7(load) {
                 const stmt = stmts[k];
                 for (const req of requiresOf7(stmt)) {
                     const loc = { file: sf.fileName, start: req.node.getStart(sf), end: req.node.getEnd() };
+                    const bindingKind = requireCallBindingKind7(program, req.node);
+                    // TypeScript source files join this scan only through the
+                    // canonical createRequire bridge. Their ordinary require-shaped
+                    // calls retain the existing checker/lowering diagnostics; JS
+                    // files keep the full CommonJS scan.
+                    if (!jsRequireFile && bindingKind !== "createRequire")
+                        continue;
                     if (isNodeEsmFile7(sf)) {
-                        const bindingKind = requireCallBindingKind7(program, req.node);
                         if (bindingKind !== "createRequire") {
                             diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                             continue;
@@ -2281,6 +2348,13 @@ function preflight7(load) {
                                 continue; // offender recorded — the fallback loop reloads
                         }
                         else {
+                            // createRequire's non-program targets belong to its own
+                            // lowering: installed packages select static-vs-island
+                            // there, and missing packages become catchable
+                            // MODULE_NOT_FOUND throws. Only resolved program targets are
+                            // module-order edges in this preflight walk.
+                            if (bindingKind === "createRequire")
+                                continue;
                             if (canonicalBuiltinModule(req.spec) === null &&
                                 !processModuleAliasRequire7(req.spec, req.decl)) {
                                 // A binding-less require of a package NOTHING resolves:
@@ -2297,6 +2371,8 @@ function preflight7(load) {
                         }
                     }
                     if (dep && dep.fileName.endsWith(".json")) {
+                        if (bindingKind === "createRequire")
+                            continue;
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
                     }
@@ -2316,8 +2392,10 @@ function preflight7(load) {
             for (const call of nestedBareRequires) {
                 const spec = requireSpecOf7(call);
                 const loc = { file: sf.fileName, start: call.getStart(sf), end: call.getEnd() };
+                const bindingKind = requireCallBindingKind7(program, call);
+                if (!jsRequireFile && bindingKind !== "createRequire")
+                    continue;
                 if (isNodeEsmFile7(sf)) {
-                    const bindingKind = requireCallBindingKind7(program, call);
                     if (bindingKind !== "createRequire") {
                         diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                         continue;
@@ -2329,6 +2407,8 @@ function preflight7(load) {
                 const projectDep = resolveImport7(program, sf, spec);
                 if (projectDep !== null) {
                     if (projectDep.fileName.endsWith(".json")) {
+                        if (bindingKind === "createRequire")
+                            continue;
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
                     }
@@ -2345,6 +2425,8 @@ function preflight7(load) {
                             deps.push({ dep: nDep });
                         continue;
                     }
+                    if (bindingKind === "createRequire")
+                        continue;
                     if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
                         // Binding-less by construction — same require-site throw
                         // channel as the statement-level form above.