@scriptc/compiler 0.4.7 → 0.4.8

package/dist/frontend/program.d.ts

@@ -1,6 +1,7 @@
 import * as ts from "./ts7/adapter.js";
 import type { ScrDiagnostic } from "../diagnostics/diagnostic.js";
 import type { FrontendServices } from "./services.js";
+import { type AdmittedOpinion } from "./tsc-codes.js";
 import { type ShapeOverlayLoadState } from "./shape-inference/index.js";
 import { type LoweredJsx } from "./jsx-source.js";
 export interface TypeWorldDifferences {
@@ -20,6 +21,13 @@ export interface LoadResult {
     /** Shape inference's overlay state for this load (restored before its
      * lowering: a later load resets the per-process registry). */
     shapeOverlayState?: ShapeOverlayLoadState;
+    /** This load's structural preflight walk: the module order and the graph
+     * facts below, plus the walk's own fences. Computed once — a fixpoint that
+     * asked for the order first completes the same walk in checkPreflight
+     * instead of repeating it. The load owns the memo. */
+    preflightStructure?: PreflightStructure;
+    /** The workspace-edge probe below already ran for this load. */
+    workspaceProbed?: true;
     /** User source files in Node's evaluation order: depth-first postorder
      * of the import graph from the entry, each module once. The entry is
      * last. Empty until checkPreflight runs (and empty when preflight fails
@@ -41,6 +49,12 @@ export interface LoadResult {
      * instead of failing the build, and the module never joins the compiled
      * graph. Filled by checkPreflight. */
     dynamicImportRejections?: ReadonlyMap<ts.SourceFile, StartupCrash> | undefined;
+    /** The JavaScript checker diagnostics preflight admitted under an opinion
+     * row (tsc-codes.ts, JS_OPINIONS), each recorded only where no other
+     * filter would have suppressed it. Empty for every program that admits
+     * none — every TypeScript program, and every JavaScript program that
+     * compiles without one. Filled by checkPreflight. */
+    admittedOpinions?: readonly AdmittedOpinion[];
     /** Node's startup refusal, when the graph carries an import edge Node
      * rejects before ANY module evaluates — a RESOLUTION refusal (a bare
      * specifier nothing installed resolves, an exports/imports map that
@@ -132,6 +146,12 @@ export declare function loadProgram(entryPath: string, services: FrontendService
  * preflight diagnostics. Preserve the caller's complete load shape when
  * mutating it, including its owned services and disposal callback. */
 export declare function checkPreflight<T extends LoadResult>(load: T): ScrDiagnostic[];
+/** The module evaluation order and the graph facts derived with it, without
+ * the diagnostics. `--npm-static`'s library fixpoint reloads the program
+ * once per package it discovers and reads the order alone (to find the next
+ * package); only the last program's diagnostics are ever reported, and its
+ * checkPreflight completes this walk instead of repeating it. */
+export declare function checkModuleOrder<T extends LoadResult>(load: T): void;
 /** The specifier of a `require("...")` call: the callee is the bare
  * identifier `require` and the single argument a string literal. The one
  * recognizer preflight edges, global collection, and statement lowering
@@ -208,6 +228,9 @@ declare function requireEarlyReference7(program: ts.Program, decl: ts.VariableDe
 export declare function requireBindingEarlyUse7(program: ts.Program, sf: ts.SourceFile, k: number, decl: ts.VariableDeclaration, precedingDecls: readonly ts.VariableDeclaration[], 
 /** A reference of the binding whose early evaluation is known exact. */
 exactEarlyRead?: (reference: ts.Identifier) => boolean): ts.Identifier | null;
+/** What a call spelled `require(...)` runs: Node's ambient loader, a
+ * createRequire binding, or a binding the file declares itself. */
+export type RequireCallBindingKind7 = "ambient" | "createRequire" | "source";
 /** True only for createRequire bindings the lowering can erase. Mutable
  * declaration syntax needs a whole-file proof: no writes or escapes, and
  * no code before initialization can reach the binding. */
@@ -218,6 +241,12 @@ export declare function isCreateRequireBinding7(program: ts.Program, callee: ts.
  * parentheses and pattern containers, exactly the shapes a sloppy-mode
  * implicit global can be introduced by. */
 export declare function isJsWriteTarget7(node: ts.Node): boolean;
+/** 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. */
+declare function requireCallBindingKind7(program: ts.Program, node: ts.Node): RequireCallBindingKind7;
 /** 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
@@ -228,6 +257,12 @@ declare function isNodeEsmFile7(sf: ts.SourceFile, program?: ts.Program): boolea
  * module.exports surfaces — `ts.isExternalModule` is NOT the CJS test:
  * tsgo marks CJS files with export assignments as external modules). */
 export declare function isCjsJsFile(sf: ts.SourceFile, program?: ts.Program): boolean;
+/** Whether `node` runs in strict mode code: inside a class body, a function
+ * with a "use strict" directive, a module, or a script that starts with
+ * "use strict". CommonJS JavaScript is sloppy otherwise; the sloppy-only
+ * semantics (implicit globals, `with`, direct eval, Annex B) need a Node
+ * island. */
+export declare function isStrictCode(node: ts.Node): boolean;
 /** A module edge, carrying what cycle admission needs when it turns out
  * to close one. `stmt` is the importing/re-exporting statement; absent
  * for require() edges, which are never admitted (their CJS home fails the
@@ -307,7 +342,12 @@ export declare function moduleEarlyBindings(program: ts.Program, order: readonly
  * program, or null (unresolvable / outside the program). Exported (as
  * resolveImport) for the lowering: CommonJS require statements lower to
  * guarded %init calls of exactly the module preflight resolved here. */
-declare function resolveImport7(program: ts.Program, from: ts.SourceFile, specifier: string, resolutionKind?: "import" | "require"): ts.SourceFile | null;
+declare function resolveImport7(program: ts.Program, from: ts.SourceFile, specifier: string, resolutionKind?: "import" | "require", 
+/** False for the graph passes that over-approximate edges (see
+ * `resolveRuntimeEdge`): they resolve specifiers Node may never load, so
+ * a miss there is no evidence about the package's entry and must not
+ * classify it. The walks that model real loads pass the default. */
+reportMiss?: boolean): ts.SourceFile | null;
 declare function resolveNpmImport7(fromFileName: string, specifier: string, resolutionKind?: "import" | "require"): {
     packageName: string;
     version?: string;
@@ -325,6 +365,26 @@ export declare function checkPreflightTs7(entryPath: string, host: ts.Ts7Host):
     diags: ScrDiagnostic[];
     moduleOrder: string[];
 };
+/** The structural half of preflight: the module evaluation order and the
+ * graph facts derived with it, plus the fence diagnostics the walk itself
+ * produces. */
+interface PreflightStructure {
+    order: ts.SourceFile[];
+    moduleEdges: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]>;
+    dynamicImportRejections: ReadonlyMap<ts.SourceFile, StartupCrash>;
+    inlineRequireCycleCalls: ReadonlySet<ts.Node>;
+    /** The graph walk's own diagnostics, in report order. The full preflight
+     * reports them right after its tsc gate. */
+    diags: ScrDiagnostic[];
+    /** Node's resolve-phase refusal, before the full preflight decides whether
+     * the remaining diagnostics let it stand (a build that already fails
+     * reports every refusal's compile fence instead). */
+    resolveCrash: StartupCrash | null;
+    /** The compile-fence diagnostic of every refusal the entry never reaches,
+     * in report order; the full preflight reports them only when nothing else
+     * fails. */
+    fallbacks: ScrDiagnostic[];
+}
 /** 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
@@ -344,7 +404,7 @@ export declare function esmNamedImportLinkCrash(program: ts.Program, entry: ts.S
 export { ambientDtsPath, fallbackDtsPath, isFallbackDtsPath, 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, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
+export { requireSpecOf7 as requireSpecOf, requireCallBindingKind7 as requireCallBindingKind, 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. */