@scriptc/compiler 0.2.9 → 0.2.10

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

@@ -1,9 +1,11 @@
 import { type CycleInitFlag } from "./cycle-initialization.js";
 import type { FieldLift } from "./coercions/structural-plans.js";
 import { CoercionState } from "./coercions/state.js";
+import { NarrowingStability } from "./narrowing-stability.js";
 import { StringIndexBounds } from "./string-index-bounds.js";
 import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
+import { type ContractAnnotations } from "../contract-types.js";
 import type { WidthLift } from "./width-lift.js";
 import { type FnCtx } from "./function-context.js";
 import type { FrontendServices } from "../services.js";
@@ -88,6 +90,9 @@ export interface LowerResult {
     /** Present iff diagnostics is empty. */
     module: IrModule | null;
     diagnostics: ScrDiagnostic[];
+    /** The program's written contract types (@scriptc/types), keyed by the
+     * source locations the IR carries; absent when it writes none. */
+    contracts?: ContractAnnotations;
     /** JS statements whose compile fences DEFERRED to runtime (runtimeFence
      * statements in the module) — off the build, on the coverage report. */
     runtimeFences: ScrDiagnostic[];
@@ -476,6 +481,10 @@ export declare class Lowerer {
      * discriminant was captured. A case match narrows the captured value,
      * not that mutable binding; preserve its tagged representation on reads. */
     readonly unstableSwitchBindings: Set<ts.Symbol>;
+    /** Whether a checker narrowing of a mutable member or closure-assigned
+     * binding still holds at its use (calls do not reset TypeScript's
+     * narrowing). Stale ones read the declared storage or check it. */
+    readonly narrowing: NarrowingStability;
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     readonly runtimeOptionalStorageLocals: Set<IrLocal>;

package/dist/frontend/lowering/lowerer.js

@@ -19,12 +19,14 @@ import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lo
 import { everyExprChild, everyStmtChild, transformStmtList } from "../../ir/traverse.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
+import { NarrowingStability } from "./narrowing-stability.js";
 import { ArrayElementStates } from "./runtime-optional-elements.js";
 import { indexReadInBounds } from "./runtime-optional-bounds.js";
 import { ArrayOwnership } from "./runtime-optional-ownership.js";
 import { StringIndexBounds } from "./string-index-bounds.js";
 import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
+import { collectContractAnnotations } from "../contract-types.js";
 import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
 import { UnregisteredClassTypes } from "./unregistered-class-types.js";
 import { bindingInContext, captureContextBinding, declareContextLocal, declareContextThis, } from "./function-context.js";
@@ -395,6 +397,39 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     timing("divergence-scan", { found: divergences.length });
     if (divergences.length > 0)
         result = { ...result, divergences };
+    // Contract types (@scriptc/types): written annotations, checked against
+    // the IR by the compile pipeline (contracts/check.ts).
+    // Acyclic object types name the IR unit the program lowered them to; a
+    // type the module never uses has no unit (mapping it now only touches the
+    // lowerer's tables, never the finished module).
+    const lowered = result.module;
+    const contracts = collectContractAnnotations(program.getTypeChecker(), moduleOrder, (type) => {
+        if (lowered === null)
+            return null;
+        const mapped = panicSafe(() => resultLowerer.mapTypeOf(type), null);
+        if (mapped?.kind === "object")
+            return lowered.classes?.some((c) => c.name === mapped.className)
+                ? `object:${mapped.className}`
+                : null;
+        if (mapped?.kind === "record")
+            return lowered.records?.some((r) => r.id === mapped.shapeId)
+                ? `record:${mapped.shapeId}`
+                : null;
+        if (mapped?.kind === "union")
+            return lowered.unions?.some((u) => u.id === mapped.unionId)
+                ? `union:${mapped.unionId}`
+                : null;
+        return null;
+    });
+    timing("contract-annotations", { found: contracts.count });
+    if (contracts.diagnostics.length > 0)
+        result = {
+            ...result,
+            module: null,
+            diagnostics: [...result.diagnostics, ...contracts.diagnostics],
+        };
+    else if (contracts.count > 0)
+        result = { ...result, contracts };
     if (options.coverage !== true)
         return result;
     const remainder = new Lowerer(program, entry, moduleOrder, dynamic, {
@@ -1219,6 +1254,10 @@ export class Lowerer {
      * discriminant was captured. A case match narrows the captured value,
      * not that mutable binding; preserve its tagged representation on reads. */
     unstableSwitchBindings = new Set();
+    /** Whether a checker narrowing of a mutable member or closure-assigned
+     * binding still holds at its use (calls do not reset TypeScript's
+     * narrowing). Stale ones read the declared storage or check it. */
+    narrowing = new NarrowingStability(this);
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     runtimeOptionalStorageLocals = new Set();
@@ -4941,6 +4980,7 @@ export class Lowerer {
     }
     run() {
         const parts = this.splitFiles();
+        this.narrowing.setFiles(parts.map((fp) => fp.sf));
         // The coverage remainder deliberately visits every body that reachable
         // emit skipped. Those files are already phase-managed, so an ordinary
         // checker miss would stay a one-node IPC query instead of falling back
@@ -5320,6 +5360,7 @@ export class Lowerer {
     emitReachable(extraRoots) {
         this.deferredModuleInitializers = new DeferredModuleInitializers();
         const parts = this.splitFiles();
+        this.narrowing.setFiles(parts.map((fp) => fp.sf));
         // Direct lowering callers do not necessarily run program preflight.
         // Establish the same managed header/top-level batch here before
         // collection, while the production path simply finds warm memos.
@@ -6145,6 +6186,12 @@ export class Lowerer {
         const narrowed = this.chainNarrowedType.get(node);
         if (narrowed)
             return narrowed;
+        // A stale narrowing of a mutable member or closure-assigned binding in
+        // an absence/type test (or a slot accepting the declared type) reads
+        // as declared, so the test inspects the stored value.
+        const widened = this.narrowing.widenedType(node);
+        if (widened)
+            return widened;
         const t = this.checker.getTypeAtLocation(node);
         // ALIASED-TYPEOF narrowing: inside a branch a `type === 'string'`
         // test proves (type = typeof val, both never reassigned), references