@scriptc/compiler 0.3.1 → 0.3.2

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

@@ -112,6 +112,10 @@ export interface ClassInfo {
      * the base chain. The value names which SIDES the class carries. User
      * `extends` of these classes is fenced at the declaration (phase 1). */
     builtinStream?: "r" | "w" | "rw";
+    /** The synthetic LifetimeRegion class (@scriptc/experimental,
+     * lifetime-regions.ts): its constructor is synthesized with the class,
+     * and its methods lower at their call sites. */
+    lifetimeRegion?: true;
     /** This class's own `emit` override in the FORWARDING SHAPE (the one
      * EventEmitter member a subclass may re-declare): never in `methods` —
      * emit calls keep routing through the emitter spoke, which lowers the
@@ -752,9 +756,6 @@ export declare function inheritsBuiltinErrorCtor(lowerer: Lowerer, info: ClassIn
 /** The EventEmitter twin: a ctor-less chain into the emitter base
  * inherits `new C()` — zero arguments (the options bag fences). */
 export declare function inheritsBuiltinEmitterCtor(lowerer: Lowerer, info: ClassInfo): boolean;
-/** Preserve argument evaluation order and option presence through builtin
- * and inherited Error constructors. Checked-dynamic conversion retains
- * Error identity and distinguishes a missing cause from undefined. */
 export declare function errorConstructorArgs(lowerer: Lowerer, args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr[];
 export declare function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr;
 /** A getter/setter invocation over an accessor target's receiver — the

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

@@ -1,4 +1,5 @@
-import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
+import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
+import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
@@ -1303,7 +1304,9 @@ mixin) {
                     lowerer.isStdlibGlobal(t.expression.expression, "globalThis")
                     ? lowerer.builtinErrorInfoOf(resolved)
                     : null;
-                if (globalError && globalError.def.name !== "%DOMException") {
+                if (globalError &&
+                    globalError.def.name !== "%DOMException" &&
+                    globalError.def.name !== "%AggregateError") {
                     if (t.typeArguments)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = globalError;
@@ -1432,6 +1435,11 @@ mixin) {
             if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%DOMException") {
                 lowerer.unsupported("SC1090", t, "extending DOMException (its runtime layout carries hidden slots a subclass would overlap — extend Error and set name/code yourself)");
             }
+            // `extends AggregateError`: the errors list is the same kind of
+            // hidden runtime slot.
+            if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%AggregateError") {
+                lowerer.unsupported("SC1090", t, "extending AggregateError (its runtime layout carries a hidden errors slot a subclass would overlap — extend Error and keep the list in a field)");
+            }
             const named = (symbol && lowerer.classBySymbol.get(symbol)) ??
                 lowerer.builtinErrorInfoOf(symbol) ??
                 lowerer.builtinEmitterInfoOf(symbol) ??
@@ -3065,6 +3073,10 @@ mixin) {
                         .map((f) => ({ name: f.name, type: f.type })),
                 ],
                 ...(methods.size > 0 ? { methods: [...methods.keys()] } : {}),
+                ...(() => {
+                    const names = classPrototypeNames(decl);
+                    return names.length > 0 ? { prototypeNames: names } : {};
+                })(),
                 ...(abstractClass ? { abstract: true } : {}),
                 ...(() => {
                     const am = [...methods.entries()].filter(([, s]) => s.abstract === true).map(([n]) => n);
@@ -5511,6 +5523,33 @@ function lowerClassCtorInner(lowerer, info) {
         lowerer.currentClass = prevClass;
     }
 }
+/** The string keys a class declaration puts on its prototype: concrete
+ * instance methods and accessors with literal names. Symbol-keyed,
+ * private, static and abstract members are not prototype string keys. */
+function classPrototypeNames(decl) {
+    const names = [];
+    for (const member of decl.members) {
+        if (!ts.isMethodDeclaration(member) &&
+            !ts.isGetAccessorDeclaration(member) &&
+            !ts.isSetAccessorDeclaration(member))
+            continue;
+        if (ts
+            .getModifiers(member)
+            ?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AbstractKeyword))
+            continue;
+        const name = member.name;
+        let text = null;
+        if (ts.isIdentifier(name) || ts.isStringLiteralLike(name))
+            text = name.text;
+        else if (ts.isNumericLiteral(name))
+            text = String(Number(name.text));
+        else if (ts.isComputedPropertyName(name) && ts.isStringLiteralLike(name.expression))
+            text = name.expression.text;
+        if (text !== null && !names.includes(text))
+            names.push(text);
+    }
+    return names;
+}
 /** The lowered method-map name of a class member: identifier text, a
  * COMPUTED name that folds to one compile-time string
  * (foldedStringKeyOf — the object-literal computed-key machinery
@@ -6615,6 +6654,67 @@ function inheritsBuiltinStreamCtor(lowerer, info) {
 /** Preserve argument evaluation order and option presence through builtin
  * and inherited Error constructors. Checked-dynamic conversion retains
  * Error identity and distinguishes a missing cause from undefined. */
+/** `new AggregateError(errors, message, options)` in the spec's order:
+ * the message and cause install first, then `errors` iterates (a
+ * non-iterable throws out of the constructor). */
+function aggregateErrorConstructor(lowerer, loc) {
+    const name = "%aggregate.new";
+    if (lowerer.liftedFns.some((fn) => fn.name === name))
+        return name;
+    const type = { kind: "object", className: "%AggregateError" };
+    const context = newFnCtx(false, null, null, type);
+    lowerer.fnStack.push(context);
+    try {
+        const params = ["errors", "message", "options"].map((id) => ({
+            localId: id,
+            name: id,
+            type: DYN,
+        }));
+        const error = varRef("error", type, loc);
+        const list = checkedIterableSpread(lowerer, varRef("errors", DYN, loc), "", loc);
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: type,
+            locals: [
+                ...params.map((p) => ({ id: p.localId, name: p.name, type: DYN, mutable: false })),
+                { id: "error", name: "error", type, mutable: false },
+                ...context.locals,
+            ],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "error",
+                    init: {
+                        kind: "libCall",
+                        fn: "error.newAggregate",
+                        args: [varRef("message", DYN, loc), varRef("options", DYN, loc)],
+                        type,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "error.aggregateSetErrors",
+                        args: [error, list],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                { kind: "return", value: error, loc },
+            ],
+            loc,
+        });
+    }
+    finally {
+        lowerer.fnStack.pop();
+    }
+    return name;
+}
 export function errorConstructorArgs(lowerer, args, loc, blame) {
     if (args.length > 2)
         lowerer.unsupported("SC1090", blame, "Error constructors with more than two arguments");
@@ -6995,6 +7095,20 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        if (errInfo && errInfo.def.name === "%AggregateError") {
+            const args = expr.arguments ?? [];
+            if (args.length > 3 || args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new AggregateError with this argument list`, expr);
+            }
+            const errors = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+            return {
+                kind: "call",
+                callee: aggregateErrorConstructor(lowerer, loc),
+                args: [errors, ...lowerer.errorConstructorArgs(args.slice(1), loc, expr)],
+                type: { kind: "object", className: "%AggregateError" },
+                loc,
+            };
+        }
         if (errInfo) {
             const args = lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr);
             return {