@scriptc/compiler 0.0.7 → 0.0.9

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

@@ -568,6 +568,19 @@ export declare function genericOverrideBelow(L: Lowerer, info: ClassInfo, name:
    * new D()` receiver is exactly D, not its annotation. Distinct from
    * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
 export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): ClassInfo | null;
+/** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
+   * checker type is a generic-callable method (`interface Repo { get<T>(id:
+   * string): T }`): the record shape maps EMPTY — generic members are
+   * excluded (no closure slot can hold a generic function) — so the
+   * copy-reshape width coercion would DROP the exact class the method
+   * calls monomorphize against, and in JS the binding IS the instance (no
+   * copy exists). The binding keeps the initializer's class
+   * representation instead: generic-method calls resolve like class-typed
+   * receivers (exactInstanceClassOf reads the same const+new discipline),
+   * and uses that want the empty record width-coerce at the use site.
+   * Const + direct `new` only — a reassignable binding or a produced
+   * value keeps today's record story and its fences. */
+export declare function genericIfaceBindingKeepsClass(L: Lowerer, decl: ts.VariableDeclaration, declaredType: IrType): boolean;
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
    * explicit) keys one instantiation of the nearest declarer's body, and
@@ -579,7 +592,7 @@ export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): C
 export declare function lowerClassGenericMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recvInfo: ClassInfo, found: {
     declarer: ClassInfo;
     info: GenericFnInfo;
-}): IrExpr;
+}, recvIr?: IrExpr): IrExpr;
 /** Wraps a derived-class expression in an upcast when the target base
    * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
 export declare function upcastTo(L: Lowerer, expr: IrExpr, className: string): IrExpr;

package/dist/frontend/lowering/lower-classes.js

@@ -4,12 +4,13 @@
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, DYN, F64, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isUnitType, typeEquals } from "../../ir/nodes.js";
+import { BOOL, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isUnitType, typeEquals } from "../../ir/nodes.js";
 import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
 import { isGenericCallableMemberType, typeKey } from "../types.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf } from "../program.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, newFnCtx, own } from "./lowerer.js";
 import { bufEncoding, lowerMapSeedArrayNew } from "./lower-containers.js";
+import { pureReemittable } from "./lower-exprs.js";
 import { lowerSearchParamsNew } from "./lower-builtins.js";
 import { requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape } from "./lower-stream.js";
@@ -2802,13 +2803,28 @@ export function lowerStaticMethodCall(L, call, access) {
         return null;
     return staticCallOn(L, call, access, info, throughValue);
 }
+/** True when a class-VALUE receiver can only hold `info`'s own class
+   * object at runtime: the receiver provably IS the class
+   * (exactClassOfReceiver — the name, or a const bound to the class
+   * expression / class name), or `info` is a LEAF class, so no strict
+   * descendant exists to flow into the slot (the static-write path's
+   * rule — a rebindable decorated name rides this arm, since replacement
+   * decorators fence any class with subclasses before minting the
+   * rebindable global). Exactly then a #private static access through
+   * the value always carries the declaring class's brand — Node's
+   * TypeError cannot arise. */
+function classValueIsExactlyOwn(L, recv, info) {
+    return exactClassOfReceiver(L, recv) === info || info.subclasses.length === 0;
+}
 function staticCallOn(L, call, access, info, throughValue) {
     const loc = locOf(call);
-    // #private statics: through-a-VALUE receivers fence (a classval slot
-    // can hold a descendant at runtime and only the declaring class
-    // object carries the brand in JS), and the direct spelling resolves
-    // only on the declaring class itself — `D.#s` is Node's TypeError.
-    if (access.name.text.startsWith("#") && throughValue) {
+    // #private statics: through-a-VALUE receiver the call devirtualizes
+    // exactly when the value can only BE the declaring class
+    // (classValueIsExactlyOwn — a slot that could hold a descendant at
+    // runtime fences, since only the declaring class object carries the
+    // brand in JS), and the direct spelling resolves only on the
+    // declaring class itself — `D.#s` is Node's TypeError.
+    if (access.name.text.startsWith("#") && throughValue && !classValueIsExactlyOwn(L, access.expression, info)) {
         L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
     }
     const found = findStaticOn(L, info, access.name.text);
@@ -2897,13 +2913,21 @@ export function lowerClassValueProperty(L, expr) {
     if (!found) {
         L.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
     }
-    // #private statics never read through class VALUES: the slot can hold
-    // a descendant at runtime and JS brands the declaring class object
-    // alone (Node's TypeError on any other receiver). The direct
-    // class-name spelling resolved in lowerStaticFieldRead, so a private
-    // reaching here is a classval-typed binding.
+    // #private statics read through a class VALUE exactly when the value
+    // can only BE the declaring class (classValueIsExactlyOwn — a const
+    // bound to the class expression / class name, or a leaf class): a
+    // slot that could hold a descendant at runtime fences, since JS
+    // brands the declaring class object alone (Node's TypeError on any
+    // other receiver). The direct class-name spelling resolved in
+    // lowerStaticFieldRead, so a private reaching here is a
+    // classval-typed binding.
     if (member.startsWith("#")) {
-        L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+        if (!classValueIsExactlyOwn(L, expr.expression, info)) {
+            L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+        }
+        if (found.declarer !== info) {
+            L.unsupported("SC1090", expr, `reading the private static '${member}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+        }
     }
     if (staticShadowBelow(L, info, member)) {
         L.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
@@ -3012,6 +3036,39 @@ export function exactInstanceClassOf(L, expr) {
         init = init.expression;
     return classOfNew(init);
 }
+/** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
+   * checker type is a generic-callable method (`interface Repo { get<T>(id:
+   * string): T }`): the record shape maps EMPTY — generic members are
+   * excluded (no closure slot can hold a generic function) — so the
+   * copy-reshape width coercion would DROP the exact class the method
+   * calls monomorphize against, and in JS the binding IS the instance (no
+   * copy exists). The binding keeps the initializer's class
+   * representation instead: generic-method calls resolve like class-typed
+   * receivers (exactInstanceClassOf reads the same const+new discipline),
+   * and uses that want the empty record width-coerce at the use site.
+   * Const + direct `new` only — a reassignable binding or a produced
+   * value keeps today's record story and its fences. */
+export function genericIfaceBindingKeepsClass(L, decl, declaredType) {
+    if (declaredType.kind !== "record")
+        return false;
+    if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
+        return false;
+    if ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
+        return false;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isNewExpression(init))
+        return false;
+    const shape = L.shapes.get(declaredType.shapeId);
+    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
+        return false;
+    const annT = L.typeOf(decl.name);
+    const props = L.checker.getPropertiesOfType(annT);
+    if (props.length === 0)
+        return false;
+    return props.every((p) => isGenericCallableMemberType(L.checker.getTypeOfSymbol(p), L.checker));
+}
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
    * explicit) keys one instantiation of the nearest declarer's body, and
@@ -3020,7 +3077,7 @@ export function exactInstanceClassOf(L, expr) {
    * runtime class could OVERRIDE the method (genericOverrideBelow) must be
    * statically exact (exactInstanceClassOf) — the override set then
    * resolves at compile time — or fences by name. */
-export function lowerClassGenericMethodCall(L, call, access, recvInfo, found) {
+export function lowerClassGenericMethodCall(L, call, access, recvInfo, found, recvIr) {
     const name = access.name.text;
     let { declarer, info } = found;
     if (genericOverrideBelow(L, recvInfo, name)) {
@@ -3038,7 +3095,7 @@ export function lowerClassGenericMethodCall(L, call, access, recvInfo, found) {
     const instance = info.implicitParams
         ? implicitCallInstance(L, call, info)
         : genericCallInstance(L, call, info);
-    const receiver = L.lowerExpr(access.expression);
+    const receiver = recvIr ?? L.lowerExpr(access.expression);
     const loc = locOf(call);
     // The declarer sits at/above the receiver's static class on the plain
     // path; the EXACT path can land below it (a base-typed const provably
@@ -4426,8 +4483,8 @@ export function lowerNew(L, expr) {
         // construct-and-set loop, pairs in array order, duplicates
         // overwrite). Other seeds — another Map, general iterables — keep
         // the fence: never silently an empty map. Unsupported key/value
-        // types get their half named specifically instead of the generic
-        // SC2001 (which fires for Map-typed slots elsewhere).
+        // types get their half named specifically instead of the component
+        // fence (SC2009, which names Map slots at value positions elsewhere).
         // `new Array<T>()` and the ELEMENTS forms (`new Array('hi', 'bye')`,
         // any argument list that is not one lone number) ARE array literals
         // — the spec's ArrayCreate + element writes. The one-NUMBER form
@@ -4514,6 +4571,20 @@ export function lowerNew(L, expr) {
                 return { kind: "mapNew", seed, type: mapped, loc };
             }
             const targs = L.checker.getTypeArguments(tsType);
+            // JAVASCRIPT `new Map()` whose arguments never resolved past
+            // Map<any, any> (no annotation, no contextual type, no seed): the
+            // WeakMap stance below — the VALUE lowers as an opaque DOM object
+            // (identity and truthiness are real), and every reached METHOD use
+            // meets its own per-site fence at runtime. The formatter's
+            // config-cache shape: module init constructs the caches
+            // unconditionally; the format path never touches them. TypeScript
+            // keeps the compile fence.
+            if (isJsSourceFile(expr.getSourceFile()) &&
+                (expr.arguments?.length ?? 0) === 0 &&
+                targs.length > 0 &&
+                targs.every((t) => (t.flags & ts.TypeFlags.Any) !== 0)) {
+                return { kind: "dynObjLit", type: DYN, loc };
+            }
             const keyIr = targs[0] ? L.mapTypeOf(targs[0]) : null;
             if (targs[0] && (!keyIr || !isSupportedMapKey(keyIr))) {
                 L.unsupported("SC1090", expr, `Map keys of type '${L.checker.typeToString(targs[0])}' ` +
@@ -4687,6 +4758,30 @@ export function lowerNew(L, expr) {
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
         if (L.isStdlibSymbol(symbol ?? undefined)) {
+            // The deprecated `new Buffer(string, encoding?)` ctor's string arm
+            // with a NON-STRING first argument and a string second: Node
+            // throws ERR_INVALID_ARG_TYPE synchronously (and DEP0005 never
+            // fires on this throwing path, so the compiled silence matches).
+            // Every other new Buffer form keeps the fence below — the
+            // constructing forms would owe the deprecation warning.
+            if (expr.expression.text === "Buffer" &&
+                expr.arguments?.length === 2 &&
+                !expr.arguments.some(ts.isSpreadElement) &&
+                L.mapTypeOf(L.typeOf(expr.arguments[0]))?.kind !== "string" &&
+                L.mapTypeOf(L.typeOf(expr.arguments[1]))?.kind === "string") {
+                const first = L.lowerExpr(expr.arguments[0]);
+                if (first.kind === "unitLit" || first.type.kind === "dyn" || L.dynConvertible(first.type)) {
+                    const got = first.type.kind === "dyn" ? first : { kind: "dynFrom", value: first, type: DYN, loc };
+                    // The encoding argument still evaluates in Node before the
+                    // throw only via the ctor body's later reads — it does NOT
+                    // observe it before throwing, so dropping it is exact for
+                    // effect-free operands; effectful ones keep the fence.
+                    const enc = L.lowerExpr(expr.arguments[1]);
+                    if (enc.kind === "strLit" || pureReemittable(enc)) {
+                        return { kind: "libCall", fn: "buffer.newStringFail", args: [got], type: bytesOf("u8"), loc };
+                    }
+                }
+            }
             const ctorHints = {
                 RegExp: "use a regex literal (/pattern/flags) — constructed regexes have no lowering",
                 String: "boxed wrapper objects have no lowering — use the string primitive (the box is only distinguishable via typeof/identity, which nothing here can honor)",
@@ -4697,6 +4792,7 @@ export function lowerNew(L, expr) {
                 WeakRef: "deref()-after-collect exposes GC timing — genuinely dynamic; hold a strong reference instead",
                 FinalizationRegistry: "finalization callbacks expose GC timing — genuinely dynamic; release resources explicitly instead",
                 SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
+                ArrayBuffer: "no free-standing ArrayBuffer value exists — typed arrays own their storage: allocate the view directly (new Uint8Array(n)), or erase a fresh buffer into one (new Uint8Array(new ArrayBuffer(n)), new DataView(new ArrayBuffer(n), ...))",
                 Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
                 Function: "runtime code generation cannot be compiled ahead of time (the eval stance) — write the function",
             };