@scriptc/compiler 0.2.9 → 0.3.0

package/dist/frontend/lowering/lower-stdlib.d.ts

@@ -0,0 +1,98 @@
+import * as ts from "../ts7/adapter.js";
+import type { Lowerer } from "./lowerer.js";
+import { type IrExpr, type IrType } from "../../ir/ir.js";
+import { type StdlibFnEntry } from "./surfaces.js";
+export declare function refuseUnsupportedApi(lowerer: Lowerer, feature: string, node: ts.Node, hint?: string): never;
+export declare function stdlibGlobalFnOf(lowerer: Lowerer, ident: ts.Identifier): StdlibFnEntry | null;
+export declare function lowerFetchCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** Static Response.json(): consume the native Response's readable body
+ * stream and parse its UTF-8 payload into the ordinary checked-dynamic
+ * JSON tree. Syntax and stream failures reject at await like the web API. */
+export declare function lowerStaticResponseCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+type StaticResponseAccess = ts.PropertyAccessExpression | ts.ElementAccessExpression;
+/** Constructor-object operations are distinct from Response instance
+ * methods. The inventory marks the former unsupported; fence
+ * them explicitly so the generic call fallback cannot report SC1090 for
+ * Response.json while the other statics report SC2020. */
+export declare function fenceUnsupportedFetchConstructorMember(lowerer: Lowerer, access: StaticResponseAccess): IrExpr | null;
+/** The adopted undici Response declaration is wider than the native static
+ * handle. Keep the supported fallback slice on checked-dynamic dispatch, but
+ * fence every other declared member before the generic dyn keyed-read/call
+ * paths can turn a missing handle operation into a runtime TypeError. */
+export declare function fenceStaticResponseMember(lowerer: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+/** Response Headers are native checked-dynamic handles. Keep their exact
+ * supported method slice aligned with the compatibility census so newly
+ * observed Node members cannot fall through to a runtime missing-method
+ * error in an engine-free build. */
+export declare function fenceStaticHeadersMember(lowerer: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+/** The native AbortController handle dispatches `abort()` directly and
+ * exposes `.signal` as data, but it has no first-class function value for
+ * the prototype method. Fence method extraction before the checked-dynamic
+ * keyed-read fallback can silently answer `undefined`. */
+export declare function fenceStaticAbortControllerMemberRead(lowerer: Lowerer, access: StaticResponseAccess): IrExpr | null;
+/** The statically represented element channel of a native Web
+ * ReadableStream. The stream itself remains an opaque checked-dynamic
+ * handle, but its generic argument is the contract reader.read() exits
+ * through. Null means this is not the standard-library ReadableStream or
+ * its element cannot be represented statically. */
+export declare function staticReadableStreamElementType(lowerer: Lowerer, node: ts.Expression): IrType | null;
+export declare function fenceFetchObjectBinding(lowerer: Lowerer, pattern: ts.ObjectBindingPattern): void;
+/** Assignment-position object destructuring is the same member-read form as
+ * a binding pattern, but its source type lives on the right-hand expression
+ * instead of the target AST. */
+export declare function fenceFetchObjectAssignment(lowerer: Lowerer, target: ts.ObjectLiteralExpression, source: ts.Expression): void;
+/** Iteration syntax invokes Headers[Symbol.iterator] without constructing
+ * an element-access node, so the member chokepoint above never sees it.
+ * Use the same SC2020 profile row for for-of, array spread, and array destructuring. */
+export declare function fenceStaticHeadersIteration(lowerer: Lowerer, node: ts.Node): void;
+/** Bracket-spelled calls on a profiled fetch/Web-stream handle. A call such
+ * as `headers["get"](name)` is still a method reference in JavaScript: the
+ * receiver must remain bound. Lower it before the generic callee-as-value
+ * path (which correctly fences bare method extraction), evaluating receiver,
+ * key, and arguments once in source order. Finite string-literal unions
+ * dispatch through fixed-name calls after the key value is captured. */
+export declare function lowerFetchElementMethodCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** The fallback ambient declaration intentionally exposes only the native
+ * stream slice, but @types/node adopts the complete WHATWG ReadableStream
+ * interface. Fence that wider surface before its checked-dynamic handle can
+ * fall through to a runtime missing-method error. */
+export declare function fenceStaticReadableStreamMember(lowerer: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+export declare function lowerStaticFetchCompanionCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** `AbortController.abort(reason?)` mutates the native signal shared with
+ * `.signal` and fetch. Preserve a mutable reason's identity just like
+ * `AbortSignal.abort(reason)`; surplus arguments still evaluate in order and
+ * are ignored by the runtime operation. */
+export declare function lowerStaticAbortControllerCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** Controller chunks and error reasons are dyn-handle calls, but unlike a
+ * general checked-dynamic boundary the Web Streams contract preserves their
+ * object identity for the reader/source callbacks that observe them. */
+export declare function lowerStaticReadableStreamControllerCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** `ReadableStream.cancel(reason)` and default-reader `cancel(reason)` pass
+ * the same reason object to the underlying source's cancel callback. Keep a
+ * live typed-reference capsule instead of the general dyn boundary's copy. */
+export declare function lowerStaticReadableStreamCancelCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** AbortSignal retains listener object identity for duplicate detection and
+ * removeEventListener(). Functions already box by closure identity; mutable
+ * record/array/bytes listeners need the same live capsule used by stream
+ * chunks so repeated crossings still denote one EventListener object. */
+export declare function lowerStaticAbortSignalListenerCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+export declare function lowerAbortControllerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
+export declare function lowerStaticReadableStreamNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
+/** Native Request and Headers values share the fetch runtime's handles. */
+export declare function lowerFetchWebNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
+export declare function lowerResponseNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
+/** A static default reader's read() exits the native checked-dynamic
+ * transport into the checker's concrete chunk type. An exact chunk type
+ * preserves ReadableStream.from(array)'s element identity; structural
+ * widening keeps the compiler's ordinary copy-based width semantics. */
+export declare function lowerStaticReadableStreamReaderCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+export declare function lowerDynamicImportCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
+export declare function lowerStdlibMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerMathProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function npmPackageOf(lowerer: Lowerer, type: ts.Type): string | null;
+export declare function npmMemberFence(lowerer: Lowerer, access: ts.PropertyAccessExpression): void;
+/** The npm package a SYMBOL is declared by, or null. The symbol half of
+ * npmPackageOf, also asked directly for import-alias bindings (whose
+ * aliased symbol is the package's export). */
+export declare function npmPackageOfSymbol(lowerer: Lowerer, sym: ts.Symbol | undefined): string | null;
+export {};