@scriptc/compiler 0.0.4 → 0.0.6

package/dist/frontend/lowering/lowerer.d.ts

@@ -195,6 +195,12 @@ export interface LowerOptions {
      * resolution walk and CJS named-import link check): the program
      * compiles to that startup crash. */
     startupCrash?: StartupCrash | null;
+    /** LIBRARY mode's reachability roots: the profile-mapped exports of the
+     * entry module. Executable builds root at the entry's top level alone
+     * (an unreferenced export dead-strips); a library's exports are called from
+     * OUTSIDE the graph, so discovery seeds them alongside the init
+     * bodies. Names are the entry file's unqualified declaration names. */
+    libRoots?: readonly string[];
 }
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
@@ -786,7 +792,7 @@ export declare class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    discover(): Set<string>;
+    discover(extraRoots?: readonly string[]): Set<string>;
     /** Discovery hook (see discover): fires when lowering resolves a
      * reference to a lowerable body. Inert in the emit pass. */
     noteEdge(name: string): void;
@@ -1210,7 +1216,7 @@ export declare class Lowerer {
      * which have no JSON serialization (a handle isn't JSON) but an honest
      * per-field construction. Recursion terminates: recursive shapes are
      * rejected at mapping time. */
-    jsvalLiftable(t: IrType): boolean;
+    jsvalLiftable(t: IrType, visiting?: Set<string>): boolean;
     /** A jsval-typed expression carrying `e`'s value into the island —
      * jsvalLiftable's constructive side. Primitives and JSON-safe composites
      * keep the jsMarshal deep copy; jsval-bearing records and arrays go
@@ -1523,6 +1529,14 @@ export declare class Lowerer {
      * through arrows (function expressions/declarations reset `this` in JS;
      * their bodies never see an enclosing method's binding). */
     resolveThis(): IrLocal | null;
+    /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
+     * the nearest binding entry without boxing, threading, or predeclaring.
+     * resolveKey mutates capture state as a side effect, and a speculative
+     * island-ness query through a context that takes no captures (a plain
+     * declared function between the origin and the reference) was an ICE —
+     * the REAL lowering path still resolves (and diagnoses) the reference
+     * itself. */
+    peekLocal(ident: ts.Identifier): IrLocal | null;
     resolveKey(symbol: ts.Symbol, blame?: ts.Node): IrLocal | null;
     isSelfReference(ident: ts.Identifier): boolean;
     lowerStmts(stmts: readonly ts.Statement[]): IrStmt[];

package/dist/frontend/lowering/lowerer.js

@@ -17,7 +17,7 @@ import * as ts from "../ts7/adapter.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, noLoweringDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
 import { provenanceActive } from "../provenance-registry.js";
-import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
+import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
 import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
@@ -148,7 +148,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
-    const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover();
+    const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover(options.libRoots);
     const emit = new Lowerer(program, entry, moduleOrder, dynamic, { reachable, targetPlatform, startupCrash });
     const result = emit.run();
     if (options.coverage !== true)
@@ -1079,9 +1079,13 @@ export class Lowerer {
             return null;
         }
         const spec = importDecl.moduleSpecifier.text;
-        if (!isRelativeSpecifier(spec))
-            return null;
-        const dep = resolveImport(this.program, importDecl.getSourceFile(), spec);
+        // Bare specifiers resolve only for opted-in --npm-static packages —
+        // their CJS entries take the same default-binding interop as a
+        // relative require; every other bare import answers null and keeps
+        // its own machinery.
+        const dep = isRelativeSpecifier(spec)
+            ? resolveImport(this.program, importDecl.getSourceFile(), spec)
+            : npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
         if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep))
             return null;
         return dep;
@@ -1575,7 +1579,7 @@ export class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    discover() {
+    discover(extraRoots) {
         const parts = this.splitFiles();
         this.collectProgram(parts);
         // Decorated classes analyze post-collection here too: the %init seeds
@@ -1683,6 +1687,12 @@ export class Lowerer {
             this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf));
             drainInstances();
         });
+        // LIBRARY mode's extra reachability roots (LowerOptions.libRoots): the
+        // profile-mapped exports are called from outside the graph, so they
+        // seed the worklist beside the init bodies. Unknown names are inert
+        // (the export-map resolution reports them as SC4002 later).
+        for (const root of extraRoots ?? [])
+            this.onEdge?.(root);
         while (queue.length > 0) {
             // A body-level poison outside the per-statement catches (a fenced
             // constructor/method parameter default lowered by declareParams):
@@ -4222,7 +4232,7 @@ export class Lowerer {
      * which have no JSON serialization (a handle isn't JSON) but an honest
      * per-field construction. Recursion terminates: recursive shapes are
      * rejected at mapping time. */
-    jsvalLiftable(t) {
+    jsvalLiftable(t, visiting = new Set()) {
         if (t.kind === "jsval")
             return true;
         if (this.boundarySafe(t))
@@ -4246,22 +4256,32 @@ export class Lowerer {
             const shape = this.shapes.get(t.shapeId);
             if (!shape || shape.tuple)
                 return false;
+            // Recursive shapes reaching here answer FALSE: this branch is the
+            // per-field island lift (jsval/bytes-bearing composites — the
+            // JSON-safe ones already answered true through boundarySafe, where
+            // a cyclic value throws the circular TypeError at the marshal), and
+            // the lift helpers walk values with no circular guard — fencing the
+            // TYPE is the honest answer.
+            if (visiting.has(t.shapeId))
+                return false;
+            visiting.add(t.shapeId);
             // An INDEX-SIGNATURE record lifts when its value slot does (dyn
             // included): declared fields write first, then the overflow keys.
-            if (shape.indexValue && !this.jsvalLiftable(shape.indexValue))
+            if (shape.indexValue && !this.jsvalLiftable(shape.indexValue, visiting))
                 return false;
-            return shape.fields.every((f) => !f.name.startsWith("%") && this.jsvalLiftable(f.type));
+            return shape.fields.every((f) => !f.name.startsWith("%") && this.jsvalLiftable(f.type, visiting));
         }
         if (t.kind === "array")
-            return this.jsvalLiftable(t.elem);
+            return this.jsvalLiftable(t.elem, visiting);
         // A union crossing IN lifts arm by arm (a runtime tag switch — see
         // unionToJsvalHelper) when every arm does: unit arms become the
         // engine's own undefined/null (which is why bare undefined-armed
         // unions lift here despite being JSON-unsafe), the rest lift as
-        // themselves. Arms never nest unions, so this terminates.
+        // themselves. Arms never nest unions, so this terminates (recursive
+        // knots pass through records, guarded above).
         if (t.kind === "union") {
             const def = this.unions.get(t.unionId);
-            return !!def && def.arms.every((a) => isUnitType(a) || this.jsvalLiftable(a));
+            return !!def && def.arms.every((a) => isUnitType(a) || this.jsvalLiftable(a, visiting));
         }
         return false;
     }
@@ -5473,6 +5493,27 @@ export class Lowerer {
     resolveThis() {
         return this.resolveKey(THIS_BINDING);
     }
+    /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
+     * the nearest binding entry without boxing, threading, or predeclaring.
+     * resolveKey mutates capture state as a side effect, and a speculative
+     * island-ness query through a context that takes no captures (a plain
+     * declared function between the origin and the reference) was an ICE —
+     * the REAL lowering path still resolves (and diagnoses) the reference
+     * itself. */
+    peekLocal(ident) {
+        let symbol = this.checker.getSymbolAtLocation(ident);
+        if (ident.parent && ts.isShorthandPropertyAssignment(ident.parent) && ident.parent.name === ident) {
+            symbol = this.checker.getShorthandAssignmentValueSymbol(ident.parent) ?? symbol;
+        }
+        if (!symbol)
+            return null;
+        for (let depth = this.fnStack.length - 1; depth >= 0; depth--) {
+            const hit = this.bindingIn(this.fnStack[depth], symbol);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
     resolveKey(symbol, blame) {
         const direct = this.bindingIn(this.ctx, symbol);
         if (direct)
@@ -5506,6 +5547,17 @@ export class Lowerer {
                 const ctx = this.fnStack[j];
                 let entry = ctx.captureBySymbol.get(symbol);
                 if (!entry) {
+                    // A context that takes NO captures (a plain declared function —
+                    // monomorphized/implicit instances lower this way) cannot carry
+                    // the binding through: the shape is a module binding whose only
+                    // storage is the init function's LOCAL (a typed-but-unmappable
+                    // const — the file-scope `new Map()` ledger idiom) read from
+                    // inside a nested instance. Fence it — in JS the statement
+                    // defers to its runtime trap like every collection failure;
+                    // asserting here was an ICE on ordinary npm-static JS.
+                    if (ctx.captures === null) {
+                        this.unsupported("SC1090", blame ?? this.checker.declarationsOf(symbol)[0] ?? this.entry, `the binding '${origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`);
+                    }
                     const count = ctx.localCounters.get(origin.name) ?? 0;
                     ctx.localCounters.set(origin.name, count + 1);
                     entry = {
@@ -5520,9 +5572,6 @@ export class Lowerer {
                     };
                     ctx.locals.push(entry);
                     ctx.captureBySymbol.set(symbol, entry);
-                    if (ctx.captures === null) {
-                        throw new Error("lowerer bug: capture threading through a non-lifted function");
-                    }
                     ctx.captures.push({ localId: entry.id, name: entry.name, type: entry.type });
                     ctx.captureSources.push(parentEntry.id);
                 }