@scriptc/compiler 0.1.1 → 0.1.2

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

@@ -35,10 +35,7 @@ export interface ClassInfo {
         ret: IrType;
         abstract?: true;
         async?: true;
-        gen?: {
-            yieldT: IrType;
-            nextT: IrType;
-        };
+        gen?: NonNullable<IrFunction["generator"]>;
     }>;
     /** OWN GENERIC instance methods (own type parameters — `m<T>(x: T)`),
      * monomorphized per call site like top-level generic functions: instance
@@ -446,7 +443,7 @@ export declare function lowerStaticFieldRead(lowerer: Lowerer, expr: ts.Property
 /** A class EXPRESSION's ClassInfo: collection on first encounter (the
    * declaration path over the shared ClassLikeDeclaration machinery, with
    * NamedEvaluation supplying the runtime .name), idempotent per node —
-   * probeLower's speculative visits and the heritage recursion reuse the
+   * tryLowerExpression's speculative visits and the heritage recursion reuse the
    * first collection. The honest v1 boundary is TOP-LEVEL evaluation
    * positions only: each evaluation of a class expression in JS mints a
    * DISTINCT class (fresh identity, fresh statics), and one immortal
@@ -514,10 +511,7 @@ export declare function findMethodOn(lowerer: Lowerer, info: ClassInfo | null, n
         ret: IrType;
         abstract?: true;
         async?: true;
-        gen?: {
-            yieldT: IrType;
-            nextT: IrType;
-        };
+        gen?: NonNullable<IrFunction["generator"]>;
     };
 } | null;
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
@@ -583,10 +577,10 @@ export declare function lowerClassCtor(lowerer: Lowerer, info: ClassInfo): IrFun
    * COMPUTED name that folds to one compile-time string
    * (foldedStringKeyOf — the object-literal computed-key machinery
    * applied to method positions; tsc late-bound the member under exactly
-   * that name), or the reserved slot "sym:iterator" for
-   * `[Symbol.iterator]` (a name no user identifier can spell — the
-   * accessor "get:x" convention; for-of, spreads, and array destructuring
-   * dispatch to it through the iterator protocol). Null for genuinely
+   * that name), or a reserved `sym:*` slot for the well-known symbols the
+   * compiler consumes as language protocols (iterator and explicit
+   * resource management). These names are unspellable as user identifiers,
+   * like the accessor `get:x` convention. Null for genuinely
    * runtime-keyed names — the computed-member fences stay. */
 export declare function classMemberNameOf(lowerer: Lowerer, name: ts.PropertyName): string | null;
 /** A class type's ITERATOR PROTOCOL shape, statically resolved: the

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

@@ -5,13 +5,14 @@ import { InternalCompilerError } from "../../errors.js";
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, DATE_T, 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/ir.js";
-import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
+import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals } from "../../ir/ir.js";
+import { MAX_GENERIC_INSTANCES, appendImplicitUndefinedReturn, generatorMeta, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
 import { isGenericCallableMemberType, typeKey } from "../type-mapper.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 { lowerMapSeedArrayNew } from "./lower-containers.js";
+import { bufEncoding } from "./containers/bytes.js";
+import { isSafeToRepeat } from "./expressions/evaluation-safety.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";
@@ -504,6 +505,72 @@ export function collectClassShape(lowerer, decl) {
         }
     }
 }
+function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
+    if (!ts.isNewExpression(initializer) || (initializer.arguments?.length ?? 0) !== 0 || !ts.isIdentifier(initializer.expression))
+        return null;
+    const collection = initializer.expression.text;
+    if (collection !== "Map" && collection !== "Set")
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(initializer.expression);
+    if (!lowerer.isStdlibSymbol(symbol))
+        return null;
+    const mapKeys = [];
+    const mapValues = [];
+    const setElements = [];
+    const mappedArgument = (argument) => {
+        const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(argument));
+        const mapped = lowerer.mapTypeOf(type);
+        if (!mapped || mapped.kind === "dyn" || mapped.kind === "jsval" || mapped.kind === "void" || isUnitType(mapped))
+            return null;
+        return mapped;
+    };
+    const visit = (node) => {
+        if (ts.isFunctionLike(node) && !ts.isArrowFunction(node))
+            return "skip";
+        if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression))
+            return undefined;
+        const receiver = node.expression.expression;
+        if (!ts.isPropertyAccessExpression(receiver) ||
+            receiver.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+            receiver.name.text !== field) {
+            return undefined;
+        }
+        if (collection === "Map" && node.expression.name.text === "set" && node.arguments.length === 2) {
+            const key = mappedArgument(node.arguments[0]);
+            const value = mappedArgument(node.arguments[1]);
+            if (key !== null && value !== null && isSupportedMapKey(key) && isSupportedMapValue(value)) {
+                mapKeys.push(key);
+                mapValues.push(value);
+            }
+        }
+        if (collection === "Set" &&
+            (node.expression.name.text === "add" || node.expression.name.text === "has" || node.expression.name.text === "delete") &&
+            node.arguments.length === 1) {
+            const element = mappedArgument(node.arguments[0]);
+            if (element !== null && isSupportedSetElem(element))
+                setElements.push(element);
+        }
+        return undefined;
+    };
+    for (const member of decl.members) {
+        const body = ts.isConstructorDeclaration(member) || ts.isMethodDeclaration(member) || ts.isAccessor(member)
+            ? member.body
+            : undefined;
+        if (body !== undefined)
+            ts.walkPreorder(body, visit);
+    }
+    const unique = (types) => {
+        const first = types[0];
+        return first !== undefined && types.every((type) => typeEquals(type, first)) ? first : null;
+    };
+    if (collection === "Map") {
+        const key = unique(mapKeys);
+        const value = unique(mapValues);
+        return key !== null && value !== null ? { kind: "map", key, value } : null;
+    }
+    const element = unique(setElements);
+    return element !== null ? { kind: "set", elem: element } : null;
+}
 export function collectClassShapeInner(lowerer, decl, jsNameOverride, inst, 
 /** MIXIN instantiation mode (lower-mixins.ts): the class inside a
  * mixin function, collected per call site — `base` is the ARGUMENT
@@ -1300,23 +1367,15 @@ mixin) {
                 const mName = classMemberNameOf(lowerer, member.name);
                 if (mName === null)
                     lowerer.unsupported("SC1090", member, "computed method names");
-                // PUBLIC generator METHODS stay fenced (virtualCall dispatch
-                // over gen-spawn wrappers has no story yet); module-level
-                // function* and object-literal *methods compile — and #PRIVATE
-                // generator methods (`*#walk()`) compile below: privates never
-                // enter vtables (a subclass redeclaration is fenced, so
-                // overrideBelow can never flip), every call is a direct call the
-                // emitter routes through the gen-spawn wrapper with `this` as
-                // param 0 — the async-method precedent, generator form.
-                if (member.asteriskToken !== undefined && !ts.isPrivateIdentifier(member.name)) {
+                // Sync PUBLIC generator methods stay fenced because virtualCall
+                // dispatch cannot hold spawn wrappers. Async generator methods
+                // use the existing static async-method dispatch discipline;
+                // overrides fence below. #private generators are always direct.
+                const asyncGenerator = member.asteriskToken !== undefined &&
+                    member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+                if (member.asteriskToken !== undefined && !asyncGenerator && !ts.isPrivateIdentifier(member.name)) {
                     lowerer.unsupported("SC1071", member, "generator methods (a #private generator method compiles — privates never dispatch dynamically; or declare a module-level function* and call it from the method)");
                 }
-                // An async #private generator (`async *#m()`) is still an async
-                // generator — the blanket SC1071 fence.
-                if (member.asteriskToken !== undefined &&
-                    member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
-                    lowerer.unsupported("SC1071", member, "async generators (async function*)");
-                }
                 // An ABSTRACT method is a signature with no body — type-world,
                 // except that it declares the vtable slot: calls through
                 // base-typed receivers are ordinary virtual dispatch, and tsc
@@ -1466,7 +1525,12 @@ mixin) {
                 if (member.asteriskToken !== undefined) {
                     if (ft.ret.kind !== "generator")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
-                    methods.set(mName, { params: shapes, ret: ft.ret, gen: { yieldT: ft.ret.yieldT, nextT: ft.ret.nextT } });
+                    methods.set(mName, {
+                        params: shapes,
+                        ret: ft.ret,
+                        gen: generatorMeta(lowerer, ft.ret),
+                        ...(asyncMember ? { async: true } : {}),
+                    });
                 }
                 else {
                     methods.set(mName, asyncMember ? { params: shapes, ret: ft.ret, async: true } : { params: shapes, ret: ft.ret });
@@ -1699,6 +1763,7 @@ mixin) {
                         }
                         const sym = lowerer.checker.getSymbolAtLocation(assign);
                         const t = sym ? lowerer.checker.getTypeOfSymbol(sym) : undefined;
+                        const rhs = stmt.expression.right;
                         // Implicit-any fields (assigned from UNTYPED ctor params —
                         // countdown.js's `this.limit = limit`) take the JS checked-
                         // dynamic fallback like every JS binding: the slot holds a dyn
@@ -1706,6 +1771,9 @@ mixin) {
                         // TS-annotated `unknown` fields keep their fence (KEEP NARROW
                         // applies where an annotation could say better).
                         let type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, assign, t)) : null;
+                        if (type?.kind === "dyn") {
+                            type = inferredEmptyCollectionFieldType(lowerer, decl, name, rhs) ?? type;
+                        }
                         if (!type || type.kind === "void")
                             lowerer.badType(assign, t ?? lowerer.typeOf(assign));
                         // A JSDoc claim the BODY contradicts (`@type {Command}`
@@ -1716,7 +1784,7 @@ mixin) {
                         // Trust-but-verify: the claim never silently narrows the
                         // runtime value.
                         {
-                            const rhsT = lowerer.typeOf(stmt.expression.right);
+                            const rhsT = lowerer.typeOf(rhs);
                             const assignsUndef = (rhsT.flags & ts.TypeFlags.Undefined) !== 0;
                             const admitsUndef = type.kind === "dyn" ||
                                 isUnitType(type) ||
@@ -2569,7 +2637,7 @@ function namedEvaluationName(expr) {
 /** A class EXPRESSION's ClassInfo: collection on first encounter (the
    * declaration path over the shared ClassLikeDeclaration machinery, with
    * NamedEvaluation supplying the runtime .name), idempotent per node —
-   * probeLower's speculative visits and the heritage recursion reuse the
+   * tryLowerExpression's speculative visits and the heritage recursion reuse the
    * first collection. The honest v1 boundary is TOP-LEVEL evaluation
    * positions only: each evaluation of a class expression in JS mints a
    * DISTINCT class (fresh identity, fresh statics), and one immortal
@@ -3355,10 +3423,10 @@ function lowerClassCtorInner(lowerer, info) {
    * COMPUTED name that folds to one compile-time string
    * (foldedStringKeyOf — the object-literal computed-key machinery
    * applied to method positions; tsc late-bound the member under exactly
-   * that name), or the reserved slot "sym:iterator" for
-   * `[Symbol.iterator]` (a name no user identifier can spell — the
-   * accessor "get:x" convention; for-of, spreads, and array destructuring
-   * dispatch to it through the iterator protocol). Null for genuinely
+   * that name), or a reserved `sym:*` slot for the well-known symbols the
+   * compiler consumes as language protocols (iterator and explicit
+   * resource management). These names are unspellable as user identifiers,
+   * like the accessor `get:x` convention. Null for genuinely
    * runtime-keyed names — the computed-member fences stay. */
 export function classMemberNameOf(lowerer, name) {
     if (ts.isIdentifier(name))
@@ -3372,8 +3440,14 @@ export function classMemberNameOf(lowerer, name) {
     let e = name.expression;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
-    if (ts.isPropertyAccessExpression(e) && lowerer.stdlibGlobalMember(e, "Symbol") === "iterator") {
-        return "sym:iterator";
+    if (ts.isPropertyAccessExpression(e)) {
+        const member = lowerer.stdlibGlobalMember(e, "Symbol");
+        if (member === "iterator" ||
+            member === "asyncIterator" ||
+            member === "dispose" ||
+            member === "asyncDispose") {
+            return `sym:${member}`;
+        }
     }
     return lowerer.foldedStringKeyOf(name.expression);
 }
@@ -3598,17 +3672,17 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     // (callTargetC routes by fn.async; `this` rides as param 0 in the
     // spawn's argument pack). Dispatch is static by construction — the
     // override fence at collection keeps async methods out of vtables.
-    const isAsync = sig.async === true && sig.ret.kind === "promise";
+    const isAsync = sig.async === true;
     // #PRIVATE GENERATOR methods: the module function is a generator
     // IrFunction — the body returns the TReturn channel, yields ride
     // ctx.generator, and every call (direct by construction — privates
     // never virtualize) enters through the emitted gen-spawn wrapper with
     // `this` in the argument pack, answering the suspended generator.
     const genCh = sig.gen !== undefined && sig.ret.kind === "generator" ? sig.gen : null;
-    const bodyReturn = isAsync && sig.ret.kind === "promise"
-        ? sig.ret.inner
-        : genCh !== null
-            ? lowerer.genBodyReturnType(sig.ret)
+    const bodyReturn = genCh !== null
+        ? lowerer.genBodyReturnType(sig.ret)
+        : isAsync && sig.ret.kind === "promise"
+            ? sig.ret.inner
             : sig.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
@@ -3623,6 +3697,7 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
         const declared = lowerer.declareParams(fnLike.parameters, sig.params);
         params.push(...declared.params);
         const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements)];
+        appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(fnLike));
         const fn = {
             name: `%${className}.${mName}`,
             params,
@@ -3666,6 +3741,7 @@ export function lowerStaticMethod(lowerer, info, name) {
         rejectStaticThis(lowerer, entry.member.body, (keyword) => `'${keyword}' in static methods (it names the RECEIVER class — a dynamic value; reference the class by name instead)`);
         const declared = lowerer.declareParams(entry.member.parameters, entry.params);
         const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements)];
+        appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(entry.member));
         const fn = {
             name: `%${info.def.name}.static:${name}`,
             params: declared.params,
@@ -4200,6 +4276,17 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
         loc,
     };
 }
+function assignedThisFieldType(lowerer, expr) {
+    const parent = expr.parent;
+    if (!ts.isBinaryExpression(parent) ||
+        parent.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+        parent.right !== expr ||
+        !ts.isPropertyAccessExpression(parent.left) ||
+        parent.left.expression.kind !== ts.SyntaxKind.ThisKeyword) {
+        return null;
+    }
+    return lowerer.currentClass?.fields.get(parent.left.name.text) ?? null;
+}
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
     // `new X(...)` where X is a package-declared class, in a static build:
@@ -4611,6 +4698,9 @@ export function lowerNew(lowerer, expr) {
                 : null;
             let tsType = lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
+            const fieldType = assignedThisFieldType(lowerer, expr);
+            if (mapped?.kind !== "map" && fieldType?.kind === "map")
+                mapped = fieldType;
             // JavaScript's `new Map()` has no type-argument syntax: the no-arg
             // constructor overload pins Map<any, any> whatever the JSDoc says
             // (`@type` on the declaration types the VARIABLE, not this
@@ -4691,7 +4781,10 @@ export function lowerNew(lowerer, expr) {
         }
         if (symbol?.name === "Set" && lowerer.isStdlibSymbol(symbol)) {
             const tsType = lowerer.typeOf(expr);
-            const mapped = lowerer.mapTypeOf(tsType);
+            let mapped = lowerer.mapTypeOf(tsType);
+            const fieldType = assignedThisFieldType(lowerer, expr);
+            if (mapped?.kind !== "set" && fieldType?.kind === "set")
+                mapped = fieldType;
             if (mapped?.kind === "set" && (expr.arguments?.length ?? 0) === 1) {
                 const argNode = expr.arguments[0];
                 // An array LITERAL seed builds element-wise (its contextual type
@@ -4851,7 +4944,7 @@ export function lowerNew(lowerer, expr) {
                     // observe it before throwing, so dropping it is exact for
                     // effect-free operands; effectful ones keep the fence.
                     const enc = lowerer.lowerExpr(expr.arguments[1]);
-                    if (enc.kind === "strLit" || pureReemittable(enc)) {
+                    if (enc.kind === "strLit" || isSafeToRepeat(enc)) {
                         return { kind: "libCall", fn: "buffer.newStringFail", args: [got], type: bytesOf("u8"), loc };
                     }
                 }