@scriptc/compiler 0.1.6 → 0.1.7

package/dist/frontend/program.js

@@ -127,6 +127,25 @@ function jsoncSyntaxError(text) {
         return e instanceof Error ? e.message : String(e);
     }
 }
+/** Preserve TypeScript 5.9's computed synthetic-default permission from the
+ * project's own module settings. Preflight later forces ESNext/Bundler for
+ * scriptc's checker, so those forced options must not decide which source
+ * import forms were legal in the original project. */
+function projectAllowsSyntheticDefaultImports(options) {
+    const explicitSyntheticDefaultImports = options["allowSyntheticDefaultImports"];
+    if (explicitSyntheticDefaultImports !== undefined)
+        return explicitSyntheticDefaultImports === true;
+    const moduleKind = options["module"];
+    const explicitEsModuleInterop = options["esModuleInterop"];
+    const esModuleInterop = explicitEsModuleInterop !== undefined
+        ? explicitEsModuleInterop === true
+        : moduleKind === ts.ModuleKind.Node16 ||
+            moduleKind === ts.ModuleKind.Node18 ||
+            moduleKind === ts.ModuleKind.Node20 ||
+            moduleKind === ts.ModuleKind.NodeNext ||
+            moduleKind === ts.ModuleKind.Preserve;
+    return esModuleInterop || moduleKind === ts.ModuleKind.System || options["moduleResolution"] === ts.ModuleResolutionKind.Bundler;
+}
 /** The project's tsconfig adoption in the 7 world: tsgo's own config parser
  * (extends chains resolved server-side), the ADOPTED_OPTIONS subset taken,
  * the rest forced, the strictNullChecks floor enforced. */
@@ -148,6 +167,9 @@ function adoptProjectConfig7(host, entryPath) {
         if (value !== undefined)
             adopted[key] = value;
     }
+    if (projectAllowsSyntheticDefaultImports(parsed.options)) {
+        adopted["allowSyntheticDefaultImports"] = true;
+    }
     // TS 7 accepts `paths`, but no longer accepts `baseUrl` as a compiler
     // option. Translate the established baseUrl+paths spelling into absolute
     // targets: the synthesized config lives beside the entry rather than the
@@ -374,7 +396,10 @@ function createRequireProgramRoots7(program) {
                     target = npm.typesFile;
                 }
             }
-            if (target === null || target.endsWith(".json"))
+            // A directory's package.json may point at a native addon. Keep it
+            // out of TypeScript's source roots so the require call can report
+            // the native-addon boundary instead of an unsupported-file error.
+            if (target === null || target.endsWith(".json") || target.endsWith(".node"))
                 return "skip";
             const normalized = tsgoPath(resolve(target));
             if (!known.has(normalized))
@@ -384,6 +409,41 @@ function createRequireProgramRoots7(program) {
     }
     return [...roots].sort();
 }
+/** Classify the explicitly selected installed package's own sources. */
+export function entryPackageFilePredicate(entryPath) {
+    const entryFile = tsgoPath(entryPath);
+    const installedAt = entryFile.lastIndexOf("/node_modules/");
+    const prefix = installedAt < 0
+        ? null
+        : entryFile.slice(0, installedAt) + "/node_modules/" + npmPackageNameOf(entryFile) + "/";
+    return (file) => {
+        const normalized = tsgoPath(file);
+        return normalized === entryFile || (prefix !== null && normalized.startsWith(prefix) &&
+            !normalized.slice(prefix.length).split("/").includes("node_modules"));
+    };
+}
+/** maxNodeModuleJsDepth omits even relative JS imports within an installed
+ * entry's own package. Add those sources as roots to the existing discovery
+ * fixpoint without raising the checker depth for other packages. */
+function entryPackageProgramRoots7(program, entryPath) {
+    if (!isNodeModulesPath(entryPath))
+        return [];
+    const belongsToEntry = entryPackageFilePredicate(entryPath);
+    const roots = new Set();
+    for (const sf of program.getSourceFiles()) {
+        if (sf.isDeclarationFile || !belongsToEntry(sf.fileName))
+            continue;
+        for (const specifier of sf.imports) {
+            if (!ts.isStringLiteralLike(specifier))
+                continue;
+            const target = resolveProjectModule(sf.fileName, specifier.text);
+            if (target !== null && belongsToEntry(target) && isJsSourceFileName(target) &&
+                program.getSourceFile(target) === undefined)
+                roots.add(target);
+        }
+    }
+    return [...roots].sort();
+}
 function loadProgram7(host, entryPath, externalTypes = new Map()) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
@@ -425,6 +485,7 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
     let program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
     for (let pass = 0; pass < 32; pass++) {
         const candidates = [
+            ...entryPackageProgramRoots7(program, entryPath),
             ...createRequireProgramRoots7(program),
             ...forkTargetPaths(program, program.getSourceFiles()),
         ];
@@ -663,25 +724,134 @@ function requiresOf7(stmt) {
     }
     return out;
 }
+/** The exact `Object.defineProperty(exports|module.exports, "__esModule",
+ * { value: true })` interop stamp (shared by preflight and the no-op lowering). */
+export 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);
+}
+/** Plain CommonJS prologue writes only publish values; in particular,
+ * publishing a hoisted function does not invoke its body. Later runnable
+ * statements may call the export or mutate its receiver, and still need
+ * the conservative TDZ scan over the whole prefix. */
+function pureCjsExport7(program, stmt) {
+    const cjs = cjsExportAssignmentOf(stmt);
+    if (cjs === null)
+        return false;
+    const sf = stmt.getSourceFile();
+    const plainMember = (left) => {
+        if (!ts.isPropertyAccessExpression(left) || left.questionDotToken)
+            return false;
+        // A replacement export can have setters or non-writable function
+        // properties. Only the wrapper's original object gets this exception.
+        if (sf.statements.some((s) => cjsExportAssignmentOf(s)?.kind === "table"))
+            return false;
+        if (left.name.text === "__proto__" || left.name.text === "__esModule")
+            return false;
+        let receiver = left.expression;
+        if (isModuleExportsAccess(receiver)) {
+            receiver = receiver.expression;
+            return ts.isIdentifier(receiver) && !sourceBinding7(program, receiver);
+        }
+        return ts.isIdentifier(receiver) && receiver.text === "exports" && !sourceBinding7(program, receiver);
+    };
+    if (cjs.kind === "member") {
+        if (!plainMember(cjs.expr.left))
+            return false;
+    }
+    else {
+        const receiver = cjs.expr.left.expression;
+        if (sourceBinding7(program, receiver))
+            return false;
+    }
+    let value = cjs.expr.right;
+    // tsc emits chains such as exports.A = exports.B = void 0.
+    while (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        if (!plainMember(value.left))
+            return false;
+        value = value.right;
+    }
+    if (ts.isVoidExpression(value) && ts.isNumericLiteral(value.expression))
+        return true;
+    if (ts.isStringLiteralLike(value) || ts.isNumericLiteral(value) ||
+        value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword ||
+        value.kind === ts.SyntaxKind.NullKeyword)
+        return true;
+    if (!ts.isIdentifier(value))
+        return false;
+    if (value.text === "undefined" && !sourceBinding7(program, value))
+        return true;
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(value);
+    return symbol !== undefined && checker.declarationsOf(symbol).some((decl) => ts.isFunctionDeclaration(decl) && decl.parent === stmt.parent);
+}
+function sourceBinding7(program, ident) {
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(ident);
+    return symbol !== undefined && checker.declarationsOf(symbol).some((decl) => !decl.getSourceFile().isDeclarationFile && !ts.isSourceFile(decl));
+}
+function purePrefixDecl7(decl) {
+    const init = decl.initializer;
+    return init === undefined || requireSpecOf7(init) !== null ||
+        ts.isStringLiteralLike(init) || ts.isNumericLiteral(init) ||
+        init.kind === ts.SyntaxKind.TrueKeyword || init.kind === ts.SyntaxKind.FalseKeyword ||
+        init.kind === ts.SyntaxKind.NullKeyword;
+}
 /** True for top-level statements that cannot run user code: directives,
  * empty statements, hoisted declarations, require statements themselves,
- * and literal-initialized variables. A require preceded ONLY by these can
- * never have its bindings observed early — nothing above it executes. */
-function purePrefixStmt7(s) {
+ * literal-initialized variables, and CommonJS function-export prologues.
+ * A require preceded ONLY by these cannot observe its own bindings early;
+ * require cycles are checked separately by the module graph fences. */
+function purePrefixStmt7(program, s) {
     if (ts.isEmptyStatement(s) || ts.isFunctionDeclaration(s))
         return true;
     if (ts.isExpressionStatement(s) && ts.isStringLiteral(s.expression))
         return true; // directive
     if (isRequireStatement7(s))
         return true;
+    if (isCjsJsFile7(s.getSourceFile())) {
+        if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
+            const call = s.expression;
+            const object = call.expression.expression;
+            let receiver = call.arguments[0];
+            if (ts.isPropertyAccessExpression(receiver))
+                receiver = receiver.expression;
+            if (!sourceBinding7(program, object) && ts.isIdentifier(receiver) && !sourceBinding7(program, receiver))
+                return true;
+        }
+        if (pureCjsExport7(program, s))
+            return true;
+    }
     if (ts.isVariableStatement(s)) {
-        return s.declarationList.declarations.every((d) => d.initializer === undefined ||
-            requireSpecOf7(d.initializer) !== null ||
-            ts.isStringLiteralLike(d.initializer) ||
-            ts.isNumericLiteral(d.initializer) ||
-            d.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-            d.initializer.kind === ts.SyntaxKind.FalseKeyword ||
-            d.initializer.kind === ts.SyntaxKind.NullKeyword);
+        return s.declarationList.declarations.every(purePrefixDecl7);
     }
     return false;
 }
@@ -700,7 +870,7 @@ function purePrefixStmt7(s) {
  * (The CheckerFacade memoizes symbol queries, and 7's client dedupes
  * symbol identity by server handle, so the Map-keyed-by-Symbol discipline
  * carries over from the 5.9.3 original unchanged.) */
-function requireTdzRisk7(program, sf, k, decl) {
+function requireTdzRisk7(program, sf, k, decl, precedingDecls) {
     const checker = program.getTypeChecker();
     const bound = [];
     if (ts.isIdentifier(decl.name))
@@ -756,12 +926,15 @@ function requireTdzRisk7(program, sf, k, decl) {
     // These are the exact roots the TDZ analysis scans eagerly. Their files
     // are phase-managed already, so warm their deferred identifiers as one
     // symbol-only batch instead of paying one IPC query per occurrence.
-    checker.prefetchSymbolRoots(stmts.slice(0, k).filter((stmt) => !ts.isFunctionDeclaration(stmt)));
-    for (let i = 0; i < k && hit === null; i++) {
-        const s = stmts[i];
-        if (ts.isFunctionDeclaration(s))
-            continue;
-        scan(s);
+    const roots = [
+        ...stmts.slice(0, k).filter((stmt) => !ts.isFunctionDeclaration(stmt)),
+        ...precedingDecls,
+    ];
+    checker.prefetchSymbolRoots(roots);
+    for (const root of roots) {
+        if (hit !== null)
+            break;
+        scan(root);
     }
     while (hit === null && work.length > 0) {
         // A scanned reference can make a hoisted declaration's body reachable
@@ -1681,6 +1854,12 @@ export function checkPreflightTs7(entryPath, sharedHost) {
 function preflight7(load) {
     const { program, entry } = load;
     const diags = [...load.configDiags];
+    // An explicit entry can itself live in an installed package. Its own
+    // source files are program code, including relative barrels and sibling
+    // modules; their location must not silently erase the module graph.
+    // Match the full installed directory, not just the package name, and
+    // exclude nested installations so dependencies keep their npm policy.
+    const entryPackageFile = entryPackageFilePredicate(entry.fileName);
     // Workspace-linked packages register BEFORE the tsc gate. Their files
     // live at realpaths OUTSIDE node_modules (the monorepo-tool symlink
     // shape), so nothing path-shaped marks them as npm surface — yet their
@@ -1808,6 +1987,7 @@ function preflight7(load) {
      * pass above), suppressed here unless --npm-static opted them into being
      * program modules. */
     const islandJsFile = (file) => isJsSourceFileName(file) &&
+        !entryPackageFile(file) &&
         npmStaticPackageOfPath(file) === null &&
         (isNodeModulesPath(file) || workspacePackageOfPath(file) !== null);
     const nodeModulesJsSuppressed = (d) => d.fileName !== undefined && islandJsFile(d.fileName);
@@ -1914,7 +2094,7 @@ function preflight7(load) {
         .filter((sf) => sf.fileName !== ambient &&
         !sf.isDeclarationFile &&
         !sf.fileName.endsWith(".json") &&
-        (!isNodeModulesPath(sf.fileName) || npmStaticPackageOfPath(sf.fileName) !== null) &&
+        (!isNodeModulesPath(sf.fileName) || entryPackageFile(sf.fileName) || npmStaticPackageOfPath(sf.fileName) !== null) &&
         !islandJsFile(sf.fileName));
     const userFiles = npmStaticActive()
         ? planNpmStaticReexports(program, entry, programFiles, [...createRequireProgramRoots7(program), ...forkTargetPaths(program, program.getSourceFiles())], (sf, spec) => resolveImport7(program, sf, spec) ?? npmStaticDepSf7(program, sf, spec))
@@ -2245,17 +2425,13 @@ function preflight7(load) {
                 // surface and the lowering keys the same tables
                 // (builtinNamespaceModuleOf's default-import twin). JS sources
                 // always (Node never asks for interop flags); TS sources when the
-                // adopted interop knobs made the checker accept the spelling
-                // (the `import os from 'os'` spelling under esModuleInterop — the
-                // program TYPECHECKED, so the form is the project's own legal
-                // dialect). A TS project without interop flags keeps the fence:
-                // the SC1012 wording beats the raw TS1259 at the same site. The
-                // callable module objects (assert, events, test) stay allowed
-                // everywhere.
-                const opts = program.getCompilerOptions();
-                const interopOn = opts.esModuleInterop === true || opts.allowSyntheticDefaultImports === true;
+                // project's explicit or implied synthetic-default permission accepts
+                // the spelling. A TS project without that permission keeps the
+                // SC1012 fence. The callable module objects (assert, events, test)
+                // stay allowed everywhere.
+                const syntheticDefaultsOn = program.getCompilerOptions().allowSyntheticDefaultImports === true;
                 const defaultOk = builtinDefaultImportModule(spec) !== null ||
-                    ((isJsSourceFileName(sf.fileName) || interopOn) && canonicalBuiltinModule(spec) !== null);
+                    ((isJsSourceFileName(sf.fileName) || syntheticDefaultsOn) && canonicalBuiltinModule(spec) !== null);
                 if (clause.name && !isJson && dep === null && !defaultOk) {
                     diags.push(unsupportedDiag("SC1012", locOf7(clause.name)));
                 }
@@ -2304,7 +2480,7 @@ function preflight7(load) {
             const stmts = sf.statements;
             let firstRunnable = -1;
             stmts.forEach((s, i) => {
-                if (firstRunnable < 0 && !purePrefixStmt7(s))
+                if (firstRunnable < 0 && !purePrefixStmt7(program, s))
                     firstRunnable = i;
             });
             for (let k = 0; k < stmts.length; k++) {
@@ -2381,8 +2557,16 @@ function preflight7(load) {
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
                     }
-                    const tdzName = firstRunnable >= 0 && firstRunnable < k && req.decl
-                        ? requireTdzRisk7(program, sf, k, req.decl)
+                    // Earlier declarators run too: `const x = read(), dep =
+                    // require('./dep')` must not lose the guard merely because both
+                    // initializers share one VariableStatement.
+                    const precedingDecls = req.decl && ts.isVariableStatement(stmt)
+                        ? stmt.declarationList.declarations.slice(0, stmt.declarationList.declarations.indexOf(req.decl))
+                        : [];
+                    const prefixCanRun = (firstRunnable >= 0 && firstRunnable < k) ||
+                        precedingDecls.some((decl) => !purePrefixDecl7(decl));
+                    const tdzName = prefixCanRun && req.decl
+                        ? requireTdzRisk7(program, sf, k, req.decl, precedingDecls)
                         : null;
                     if (tdzName !== null) {
                         diags.push(unsupportedDiag("SC1013", loc, `require() below code that can reach its binding '${tdzName}' (Node initializes the binding AT the require and throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`));