@scriptc/compiler 0.0.22 → 0.0.24

package/dist/frontend/program.js

@@ -28,11 +28,10 @@
  *    in tsc codes at all: cjsExportDiscardReason (lowering) names every
  *    genuinely discarded export, so relaxing the checker's stricter
  *    modeling loses nothing.
- *  - isNodeEsmFile: 5.9.3 under bundler sets impliedNodeFormat ONLY for
- *    .mjs/.cjs-family files (probed) and falls back to syntactic module
- *    detection for .js/.ts; 7's client SourceFile has no impliedNodeFormat,
- *    so this lane spells exactly that observed behavior: extensions first,
- *    then externalModuleIndicator.
+ *  - isNodeEsmFile: 7's client SourceFile has no impliedNodeFormat, so this
+ *    lane spells Node's format decision directly: fixed extensions first,
+ *    then an explicit nearest-package `type`, then syntax detection for
+ *    ambiguous .js/.ts files.
  *  - Malformed tsconfig.json: tsgo's parseConfigFile swallows JSONC syntax
  *    errors (recovers to empty options) where 5.9.3 reported a passthrough
  *    diagnostic, so this lane validates the config's JSONC syntax itself
@@ -43,8 +42,8 @@ import { builtinModules } from "node:module";
 import { statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import * as ts from "./ts7/adapter.js";
-import { strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
-import { isNodeModulesPath, nearestPkgJsonPath, projectDtsRuntimeSibling, resolveBareModule, resolveProjectImport, resolveRelativeModule, resolveTypeDirective, setProjectRealm } from "./resolve.js";
+import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
+import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, projectDtsRuntimeSibling, resolveBareModule, resolveProjectImport, resolveRelativeModule, resolveTypeDirective, setProjectRealm } from "./resolve.js";
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
 import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticPackages } from "./npm-static.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
@@ -57,6 +56,14 @@ const FORCED_OPTIONS = {
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.Bundler,
+    // Every file Node executes has its own lexical module wrapper: ESM has a
+    // module environment and CommonJS has the per-file function wrapper. In
+    // particular, an ambiguous file whose ONLY ESM marker is top-level await
+    // must not remain a TypeScript global script (otherwise declarations in
+    // sibling files merge and reads cross module boundaries). Runtime format
+    // classification is intentionally independent below; this option is only
+    // the binder's scope decision.
+    moduleDetection: ts.ModuleDetectionKind.Force,
     lib: ["lib.es2025.d.ts"],
     types: [],
     allowImportingTsExtensions: true,
@@ -540,17 +547,198 @@ function nestedBareRequiresOf7(sf) {
     });
     return out;
 }
-/** True when Node would treat this file as an ES MODULE (never defining
- * require/__dirname there): .mjs always, .cjs never, and .js/.ts by
- * syntactic module detection — spelled to 5.9.3's OBSERVED bundler-mode
- * behavior (it set impliedNodeFormat only for the mjs/cjs families; 7's
- * client SourceFile has no impliedNodeFormat at all). */
-function isNodeEsmFile7(sf) {
-    if (sf.fileName.endsWith(".cjs") || sf.fileName.endsWith(".cts"))
+function stripRequireCasts7(expr) {
+    let cur = expr;
+    while (ts.isParenthesizedExpression(cur) ||
+        ts.isAsExpression(cur) ||
+        ts.isTypeAssertion(cur) ||
+        ts.isNonNullExpression(cur)) {
+        cur = cur.expression;
+    }
+    return cur;
+}
+/** The supported-builtin provenance of an imported identifier, narrowed to
+ * the one member this preflight distinction needs. Mirrors the lowering's
+ * builtinImportOf alias handling so a re-export facade remains supported. */
+function isCreateRequireImport7(program, ident) {
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(ident);
+    const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined;
+    if (decl === undefined || !ts.isImportSpecifier(decl))
         return false;
-    if (sf.fileName.endsWith(".mjs") || sf.fileName.endsWith(".mts"))
+    const importDecl = decl.parent.parent.parent;
+    if (ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
+        const module = canonicalBuiltinModule(importDecl.moduleSpecifier.text);
+        const member = decl.propertyName?.text ?? decl.name.text;
+        if (module === "module" && member === "createRequire")
+            return true;
+    }
+    if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+        const target = checker.getAliasedSymbol(symbol);
+        const targetDecl = checker.declarationsOf(target)[0];
+        if (targetDecl !== undefined && targetDecl.getSourceFile().isDeclarationFile) {
+            for (let p = targetDecl.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+                if (ts.isModuleDeclaration(p) && ts.isStringLiteral(p.name)) {
+                    return canonicalBuiltinModule(p.name.text) === "module" && target.name === "createRequire";
+                }
+            }
+        }
+    }
+    return false;
+}
+/** True only for the createRequire binding shape the lowering recognizes:
+ * a const initialized from node:module's createRequire with a base naming
+ * the current file. Arbitrary source declarations named `require` must not
+ * ride the module-edge lowering, which would erase their calls. */
+function isCreateRequireBinding7(program, callee) {
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(callee);
+    const decl = symbol
+        ? checker.declarationsOf(symbol).find((d) => ts.isVariableDeclaration(d))
+        : undefined;
+    if (decl === undefined ||
+        decl.initializer === undefined ||
+        !ts.isVariableDeclarationList(decl.parent) ||
+        (decl.parent.flags & ts.NodeFlags.Const) === 0) {
+        return false;
+    }
+    const init = stripRequireCasts7(decl.initializer);
+    if (!ts.isCallExpression(init) ||
+        init.questionDotToken !== undefined ||
+        !ts.isIdentifier(init.expression) ||
+        !isCreateRequireImport7(program, init.expression) ||
+        init.arguments.length !== 1) {
+        return false;
+    }
+    const base = stripRequireCasts7(init.arguments[0]);
+    if (ts.isIdentifier(base) && base.text === "__filename")
         return true;
-    return ts.isExternalModule(sf);
+    return (ts.isPropertyAccessExpression(base) &&
+        base.questionDotToken === undefined &&
+        ts.isMetaProperty(base.expression) &&
+        base.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
+        (base.name.text === "url" || base.name.text === "filename"));
+}
+/** Classifies a require-shaped call as Node's ambient CommonJS global, the
+ * one supported createRequire source binding, or another source binding.
+ * The scanners still collect createRequire calls because they carry static
+ * 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;
+    if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+        return "ambient";
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(call.expression);
+    if (symbol === undefined)
+        return "ambient";
+    const decls = checker.declarationsOf(symbol);
+    if (decls.length === 0 || decls.every((d) => d.getSourceFile().isDeclarationFile))
+        return "ambient";
+    return isCreateRequireBinding7(program, call.expression) ? "createRequire" : "source";
+}
+function esmRequireFeature7(kind) {
+    return kind === "ambient"
+        ? "require() in an ES module (Node throws ReferenceError — use import)"
+        : "calls through a source binding named 'require' (this spelling is reserved for CommonJS/createRequire module edges — rename the binding)";
+}
+const CJS_WRAPPER_NAMES = new Set(["require", "module", "exports", "__dirname", "__filename"]);
+function bindingDeclaresCjsWrapper7(name) {
+    if (ts.isIdentifier(name))
+        return CJS_WRAPPER_NAMES.has(name.text) ? name : null;
+    for (const el of name.elements) {
+        if (el.name === undefined)
+            continue;
+        const hit = bindingDeclaresCjsWrapper7(el.name);
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}
+function insideFunctionLike7(node) {
+    for (let p = node.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+        if (ts.isFunctionLike(p))
+            return true;
+    }
+    return false;
+}
+/** The first syntax marker Node's ambiguous-file detector recognizes. This
+ * cannot use ts.isExternalModule: moduleDetection=force deliberately gives
+ * EVERY executable file module-local checker scope, including CommonJS.
+ * Runtime classification remains Node's own narrower question: value-level
+ * import/export forms, import.meta, top-level await/for-await, or a top-level
+ * lexical declaration that would redeclare a CommonJS wrapper binding. */
+function nodeEsmSyntaxMarker7(sf) {
+    for (const stmt of sf.statements) {
+        if (ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt))
+            return stmt;
+        if (ts.isExportDeclaration(stmt) &&
+            !stmt.isTypeOnly &&
+            !erasedTypeOnlyReexport(stmt)) {
+            return stmt;
+        }
+        if (ts.isExportAssignment(stmt))
+            return stmt;
+        if (ts.canHaveModifiers(stmt) &&
+            ts.getModifiers(stmt)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true) {
+            return stmt;
+        }
+        if (ts.isVariableStatement(stmt) &&
+            (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0) {
+            for (const decl of stmt.declarationList.declarations) {
+                const hit = bindingDeclaresCjsWrapper7(decl.name);
+                if (hit !== null)
+                    return hit;
+            }
+        }
+        if (ts.isClassDeclaration(stmt) && stmt.name !== undefined && CJS_WRAPPER_NAMES.has(stmt.name.text)) {
+            return stmt.name;
+        }
+    }
+    let found = null;
+    ts.walkPreorder(sf, (node) => {
+        if (ts.isMetaProperty(node) &&
+            node.keywordToken === ts.SyntaxKind.ImportKeyword) {
+            found = node;
+            return "stop";
+        }
+        if (!insideFunctionLike7(node) &&
+            (ts.isAwaitExpression(node) ||
+                (ts.isForOfStatement(node) && node.awaitModifier !== undefined))) {
+            found = node;
+            return "stop";
+        }
+        return undefined;
+    });
+    return found;
+}
+const nodeEsmFileCache7 = new WeakMap();
+/** True when Node would treat this file as an ES MODULE (never defining
+ * require/__dirname there): fixed extensions first, then an explicit
+ * nearest-package type, then Node's syntax markers for ambiguous .js/.ts
+ * files. TypeScript's external-module bit is forced for checker scoping and
+ * therefore intentionally plays no part in this runtime decision. */
+function isNodeEsmFile7(sf) {
+    const cached = nodeEsmFileCache7.get(sf);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    if (sf.fileName.endsWith(".cjs") || sf.fileName.endsWith(".cts")) {
+        result = false;
+    }
+    else if (sf.fileName.endsWith(".mjs") || sf.fileName.endsWith(".mts")) {
+        result = true;
+    }
+    else {
+        const packageType = nearestPackageType(sf.fileName);
+        result = packageType === "module"
+            ? true
+            : packageType === "commonjs"
+                ? false
+                : nodeEsmSyntaxMarker7(sf) !== null;
+    }
+    nodeEsmFileCache7.set(sf, result);
+    return result;
 }
 /** A JavaScript source file Node treats as CommonJS (not an ES module):
  * ESM namespace/default machinery must not claim it — its export surface
@@ -1462,6 +1650,28 @@ function preflight7(load) {
         // files (a workspace package imported bare AND reached relatively)
         // stay program source — only the island-bound JS steps out.
         !islandJsFile(sf.fileName));
+    // Node stops at the nearest package.json even when it is malformed, and
+    // an explicit CommonJS scope (or .cjs/.cts extension) disables ambiguous-
+    // file syntax detection entirely. TypeScript's bundler checker models
+    // neither loader rule, so restore them before any module-edge analysis:
+    // one malformed-scope diagnostic per package file, and one pointed syntax
+    // diagnostic per CommonJS source file.
+    const invalidPackageConfigs = new Set();
+    for (const sf of userFiles) {
+        const invalidConfig = nearestInvalidPackageJsonPath(sf.fileName);
+        if (invalidConfig !== null) {
+            if (!invalidPackageConfigs.has(invalidConfig)) {
+                invalidPackageConfigs.add(invalidConfig);
+                diags.push(invalidPackageConfigDiag(invalidConfig, { file: sf.fileName, start: 0, end: 0 }));
+            }
+            continue;
+        }
+        if (!isNodeEsmFile7(sf)) {
+            const marker = nodeEsmSyntaxMarker7(sf);
+            if (marker !== null)
+                diags.push(commonJsModuleSyntaxDiag(locOf7(marker)));
+        }
+    }
     const ambientModules = new Set(SUPPORTED_NODE_MODULES);
     // Ambient `declare module "name"` declarations anywhere in the program —
     // exact names and `*` patterns — so the import fence can say "type
@@ -1820,8 +2030,11 @@ function preflight7(load) {
                 for (const req of requiresOf7(stmt)) {
                     const loc = { file: sf.fileName, start: req.node.getStart(sf), end: req.node.getEnd() };
                     if (isNodeEsmFile7(sf)) {
-                        diags.push(unsupportedDiag("SC1013", loc, "require() in an ES module (Node throws ReferenceError — use import)"));
-                        continue;
+                        const bindingKind = requireCallBindingKind7(program, req.node);
+                        if (bindingKind !== "createRequire") {
+                            diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
+                            continue;
+                        }
                     }
                     if (load.externalTypes.has(req.spec)) {
                         continue;
@@ -1885,40 +2098,45 @@ function preflight7(load) {
                         deps.push({ dep });
                 }
             }
-            if (!ts.isExternalModule(sf)) {
-                for (const call of nestedBareRequiresOf7(sf)) {
-                    const spec = requireSpecOf7(call);
-                    const loc = { file: sf.fileName, start: call.getStart(sf), end: call.getEnd() };
-                    if (load.externalTypes.has(spec)) {
+            for (const call of nestedBareRequiresOf7(sf)) {
+                const spec = requireSpecOf7(call);
+                const loc = { file: sf.fileName, start: call.getStart(sf), end: call.getEnd() };
+                if (isNodeEsmFile7(sf)) {
+                    const bindingKind = requireCallBindingKind7(program, call);
+                    if (bindingKind !== "createRequire") {
+                        diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                         continue;
                     }
-                    if (!isRelativeSpecifier(spec)) {
-                        // --npm-static: opted-in packages ride the program-module edge
-                        // (the statement-level require branch above).
-                        const npmReq = !spec.startsWith("#") ? resolveNpmImport7(sf.fileName, spec) : null;
-                        if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
-                            const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
-                            if (nDep !== null)
-                                deps.push({ dep: nDep });
-                            continue;
-                        }
-                        if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
-                            // Binding-less by construction — same require-site throw
-                            // channel as the statement-level form above.
-                            if (probeNodeRequireRefusal(sf.fileName, spec) === null) {
-                                diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(spec)));
-                            }
-                        }
+                }
+                if (load.externalTypes.has(spec)) {
+                    continue;
+                }
+                if (!isRelativeSpecifier(spec)) {
+                    // --npm-static: opted-in packages ride the program-module edge
+                    // (the statement-level require branch above).
+                    const npmReq = !spec.startsWith("#") ? resolveNpmImport7(sf.fileName, spec) : null;
+                    if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
+                        const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
+                        if (nDep !== null)
+                            deps.push({ dep: nDep });
                         continue;
                     }
-                    const dep = resolveImport7(program, sf, spec);
-                    if (dep && dep.fileName.endsWith(".json")) {
-                        diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
-                        continue;
+                    if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
+                        // Binding-less by construction — same require-site throw
+                        // channel as the statement-level form above.
+                        if (probeNodeRequireRefusal(sf.fileName, spec) === null) {
+                            diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(spec)));
+                        }
                     }
-                    if (dep)
-                        deps.push({ dep });
+                    continue;
+                }
+                const dep = resolveImport7(program, sf, spec);
+                if (dep && dep.fileName.endsWith(".json")) {
+                    diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
+                    continue;
                 }
+                if (dep)
+                    deps.push({ dep });
             }
         }
     }