@scriptc/compiler 0.2.4 → 0.2.5

package/dist/frontend/lowering/class-prototypes.js

@@ -1,9 +1,9 @@
+import { dynUndefinedExpr, varRef } from "../../ir/build.js";
 import * as ts from "../ts7/adapter.js";
-import { BOOL, DYN, STRING, SYMBOL_T, isUnitType } from "../../ir/ir.js";
-import { varRef } from "../../ir/build.js";
+import { BOOL, DYN, STRING, SYMBOL_T, isUnitType, } from "../../ir/ir.js";
 import { locOf } from "../program.js";
-import { classMemberNameOf, classValueRef, exactClassOfReceiver, storedClassValueType, findGenericMethodOn, findMethodOn } from "./lower-classes.js";
-import { dynUndefinedExpr, newFnCtx } from "./lowerer.js";
+import { classMemberNameOf, classValueRef, exactClassOfReceiver, storedClassValueType, findGenericMethodOn, findMethodOn, } from "./lower-classes.js";
+import { newFnCtx } from "./lowerer.js";
 import { classMethodValue } from "./class-method-values.js";
 /** Data added to a top-level class prototype has shared identity and remains
  * separate from instance fields. Allocate lazily so inheritance and module
@@ -13,24 +13,70 @@ export function classPrototypeData(lowerer, info, loc, receiver, metadataOnly =
         if (!receiver)
             return null;
         info.localPrototypeData = true;
-        const value = receiver.type.kind === "classval" ? receiver : {
-            kind: "fieldGet", obj: receiver, className: info.def.name, field: `%classEnvironment:${info.def.name}`,
-            type: { kind: "classval", className: info.def.name }, loc,
+        const value = receiver.type.kind === "classval"
+            ? receiver
+            : {
+                kind: "fieldGet",
+                obj: receiver,
+                className: info.def.name,
+                field: `%classEnvironment:${info.def.name}`,
+                type: { kind: "classval", className: info.def.name },
+                loc,
+            };
+        const base = info.callableBase
+            ? {
+                kind: "libCall",
+                fn: "dyn.classBasePrototype",
+                args: [
+                    {
+                        kind: "libCall",
+                        fn: "dyn.getPrototype",
+                        args: [{ kind: "dynFrom", value, type: DYN, loc }],
+                        type: DYN,
+                        loc,
+                    },
+                ],
+                type: DYN,
+                loc,
+            }
+            : info.base && !info.base.builtinError
+                ? classPrototypeData(lowerer, info.base, loc, {
+                    kind: "dynCheck",
+                    value: {
+                        kind: "libCall",
+                        fn: "dyn.getPrototype",
+                        args: [{ kind: "dynFrom", value, type: DYN, loc }],
+                        type: DYN,
+                        loc,
+                    },
+                    type: { kind: "classval", className: info.base.def.name },
+                    loc,
+                })
+                : null;
+        return {
+            kind: "libCall",
+            fn: "dyn.classPrototype",
+            args: [{ kind: "dynFrom", value, type: DYN, loc }, base ?? dynUndefinedExpr(loc)],
+            type: DYN,
+            loc,
         };
-        const base = info.callableBase ? { kind: "libCall", fn: "dyn.classBasePrototype", args: [
-                { kind: "libCall", fn: "dyn.getPrototype", args: [{ kind: "dynFrom", value, type: DYN, loc }], type: DYN, loc },
-            ], type: DYN, loc }
-            : info.base && !info.base.builtinError ? classPrototypeData(lowerer, info.base, loc, { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.getPrototype", args: [{ kind: "dynFrom", value, type: DYN, loc }], type: DYN, loc },
-                type: { kind: "classval", className: info.base.def.name }, loc }) : null;
-        return { kind: "libCall", fn: "dyn.classPrototype", args: [
-                { kind: "dynFrom", value, type: DYN, loc }, base ?? dynUndefinedExpr(loc),
-            ], type: DYN, loc };
     }
-    if (info.mixinInstance || info.generic || info.genericInstance || info.def.runtime || info.builtinEmitter || info.builtinStream || info.builtinError)
+    if (info.mixinInstance ||
+        info.generic ||
+        info.genericInstance ||
+        info.def.runtime ||
+        info.builtinEmitter ||
+        info.builtinStream ||
+        info.builtinError)
         return null;
     if (info.def.prototypeDataHelper === undefined) {
-        const base = info.callableBase ? varRef(info.callableBase.prototypeId, DYN, loc)
-            : info.base && !info.base.builtinError ? classPrototypeData(lowerer, info.base, loc, info.def.baseValueGlobal ? varRef(info.def.baseValueGlobal, { kind: "classval", className: info.base.def.name }, loc) : undefined, metadataOnly) : null;
+        const base = info.callableBase
+            ? varRef(info.callableBase.prototypeId, DYN, loc)
+            : info.base && !info.base.builtinError
+                ? classPrototypeData(lowerer, info.base, loc, info.def.baseValueGlobal
+                    ? varRef(info.def.baseValueGlobal, { kind: "classval", className: info.base.def.name }, loc)
+                    : undefined, metadataOnly)
+                : null;
         if (info.base && !info.base.builtinError && base === null)
             return null;
         const name = `%prototype.data.${info.def.name}`;
@@ -38,18 +84,49 @@ export function classPrototypeData(lowerer, info, loc, receiver, metadataOnly =
         const readyId = `${globalId}.ready`;
         info.def.prototypeDataHelper = name;
         const className = info.def.jsName ?? info.def.name;
-        lowerer.globalsList.push({ id: globalId, name: `${className}.prototype`, type: DYN, mutable: true });
-        lowerer.globalsList.push({ id: readyId, name: `${className}.prototype.ready`, type: BOOL, mutable: true });
+        lowerer.globalsList.push({
+            id: globalId,
+            name: `${className}.prototype`,
+            type: DYN,
+            mutable: true,
+        });
+        lowerer.globalsList.push({
+            id: readyId,
+            name: `${className}.prototype.ready`,
+            type: BOOL,
+            mutable: true,
+        });
         const value = varRef(globalId, DYN, loc);
         const helper = {
-            name, params: [], returnType: DYN, locals: [], loc, speculativeDispatch: true,
+            name,
+            params: [],
+            returnType: DYN,
+            locals: [],
+            loc,
+            speculativeDispatch: true,
             body: [
-                { kind: "if", cond: { kind: "unary", op: "!", operand: varRef(readyId, BOOL, loc), type: BOOL, loc }, then: [
-                        { kind: "assign", localId: globalId, value: base
+                {
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: varRef(readyId, BOOL, loc), type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "assign",
+                            localId: globalId,
+                            value: base
                                 ? { kind: "libCall", fn: "dyn.objCreate", args: [base], type: DYN, loc }
-                                : { kind: "dynObjLit", fields: [], type: DYN, loc }, loc },
-                        { kind: "assign", localId: readyId, value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
-                    ], else_: null, loc },
+                                : { kind: "dynObjLit", fields: [], type: DYN, loc },
+                            loc,
+                        },
+                        {
+                            kind: "assign",
+                            localId: readyId,
+                            value: { kind: "boolLit", value: true, type: BOOL, loc },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                },
                 { kind: "return", value, loc },
             ],
         };
@@ -67,21 +144,51 @@ export function classPrototypeData(lowerer, info, loc, receiver, metadataOnly =
             const compiled = classMethodValue(lowerer, access, info, method, locOf(access));
             if (!compiled)
                 continue;
-            const descriptor = { kind: "dynObjLit", fields: [
-                    { key: { kind: "strLit", value: "value", type: STRING, loc }, value: lowerer.coerceToExpected(compiled, DYN) },
-                    { key: { kind: "strLit", value: "writable", type: STRING, loc }, value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN) },
-                    { key: { kind: "strLit", value: "configurable", type: STRING, loc }, value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN) },
-                ], type: DYN, loc };
+            const descriptor = {
+                kind: "dynObjLit",
+                fields: [
+                    {
+                        key: { kind: "strLit", value: "value", type: STRING, loc },
+                        value: lowerer.coerceToExpected(compiled, DYN),
+                    },
+                    {
+                        key: { kind: "strLit", value: "writable", type: STRING, loc },
+                        value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN),
+                    },
+                    {
+                        key: { kind: "strLit", value: "configurable", type: STRING, loc },
+                        value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN),
+                    },
+                ],
+                type: DYN,
+                loc,
+            };
             const init = helper.body[0];
             if (init.kind === "if")
-                init.then.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.defineProperty", args: [value,
-                            lowerer.coerceToExpected({ kind: "strLit", value: method, type: STRING, loc }, DYN), descriptor], type: DYN, loc }, loc });
+                init.then.push({
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "dyn.defineProperty",
+                        args: [
+                            value,
+                            lowerer.coerceToExpected({ kind: "strLit", value: method, type: STRING, loc }, DYN),
+                            descriptor,
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                });
         }
     }
     return { kind: "call", callee: info.def.prototypeDataHelper, args: [], type: DYN, loc };
 }
 export function hasClassPrototypeData(info) {
-    return info.callableBase !== undefined || info.localPrototypeData === true || info.def.prototypeDataHelper !== undefined || (info.base !== null && hasClassPrototypeData(info.base));
+    return (info.callableBase !== undefined ||
+        info.localPrototypeData === true ||
+        info.def.prototypeDataHelper !== undefined ||
+        (info.base !== null && hasClassPrototypeData(info.base)));
 }
 /** Populate the shared prototype view before exposing it to reflection.
  * Methods and accessors are non-enumerable and retain declaration identity. */
@@ -93,7 +200,12 @@ export function reflectClassPrototype(lowerer, info, loc, receiver) {
         const name = `%prototype.refusal:${info.def.name}`;
         if (!lowerer.liftedFns.some((fn) => fn.name === name))
             lowerer.liftedFns.push({
-                name, params: [], locals: [], returnType: DYN, body: [{ kind: "runtimeFence", code: "SC1090", message, loc }], loc,
+                name,
+                params: [],
+                locals: [],
+                returnType: DYN,
+                body: [{ kind: "runtimeFence", code: "SC1090", message, loc }],
+                loc,
             });
         info.prototypeReflectionRefusal = name;
         return { kind: "call", callee: name, args: [], type: DYN, loc };
@@ -108,7 +220,8 @@ export function reflectClassPrototype(lowerer, info, loc, receiver) {
         return refuse("prototype reflection on a function-local class is not supported yet");
     if (info.base && !info.base.builtinError) {
         reflectClassPrototype(lowerer, info.base, loc, info.def.baseValueGlobal
-            ? varRef(info.def.baseValueGlobal, { kind: "classval", className: info.base.def.name }, loc) : receiver);
+            ? varRef(info.def.baseValueGlobal, { kind: "classval", className: info.base.def.name }, loc)
+            : receiver);
         if (info.base.prototypeReflectionRefusal)
             return refuse("prototype reflection with this base class is not supported yet");
     }
@@ -122,36 +235,68 @@ export function reflectClassPrototype(lowerer, info, loc, receiver) {
     // Lowering passes may have rebuilt these statements, so match their
     // operation instead of relying on the original statement's identity.
     initialization.then = initialization.then.filter((statement) => !(statement.kind === "exprStmt" &&
-        (statement.expr.kind === "libCall" && statement.expr.fn === "dyn.defineProperty" ||
-            statement.expr.kind === "call" && statement.expr.callee === "%dyn.class.defineProperty")));
-    const define = (key, fields) => ({ kind: "exprStmt", expr: {
-            kind: "libCall", fn: "dyn.defineProperty", args: [prototype, lowerer.coerceToExpected(key, DYN), {
-                    kind: "dynObjLit", fields: [...fields, { key: "configurable", value: { kind: "boolLit", value: true, type: BOOL, loc } }].map((field) => ({
-                        key: { kind: "strLit", value: field.key, type: STRING, loc }, value: lowerer.coerceToExpected(field.value, DYN),
-                    })), type: DYN, loc,
-                }], type: DYN, loc,
-        }, loc });
-    const writable = { key: "writable", value: { kind: "boolLit", value: true, type: BOOL, loc } };
+        ((statement.expr.kind === "libCall" && statement.expr.fn === "dyn.defineProperty") ||
+            (statement.expr.kind === "call" && statement.expr.callee === "%dyn.class.defineProperty"))));
+    const define = (key, fields) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "dyn.defineProperty",
+            args: [
+                prototype,
+                lowerer.coerceToExpected(key, DYN),
+                {
+                    kind: "dynObjLit",
+                    fields: [
+                        ...fields,
+                        {
+                            key: "configurable",
+                            value: { kind: "boolLit", value: true, type: BOOL, loc },
+                        },
+                    ].map((field) => ({
+                        key: { kind: "strLit", value: field.key, type: STRING, loc },
+                        value: lowerer.coerceToExpected(field.value, DYN),
+                    })),
+                    type: DYN,
+                    loc,
+                },
+            ],
+            type: DYN,
+            loc,
+        },
+        loc,
+    });
+    const writable = {
+        key: "writable",
+        value: { kind: "boolLit", value: true, type: BOOL, loc },
+    };
     initialization.then.push(define({ kind: "strLit", value: "constructor", type: STRING, loc }, [
-        { key: "value", value: classValueRef(lowerer, info, info.decl) }, writable,
+        { key: "value", value: classValueRef(lowerer, info, info.decl) },
+        writable,
     ]));
     const context = newFnCtx(false, null, null, DYN);
     lowerer.fnStack.push(context);
     try {
         for (const member of info.decl.members) {
-            if ((!ts.isMethodDeclaration(member) && !ts.isAccessor(member)) || !member.body || ts.isPrivateIdentifier(member.name) ||
+            if ((!ts.isMethodDeclaration(member) && !ts.isAccessor(member)) ||
+                !member.body ||
+                ts.isPrivateIdentifier(member.name) ||
                 ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
                 continue;
             const name = classMemberNameOf(lowerer, member.name);
             if (name === null)
                 return refuse("prototype reflection with an unresolved computed member is not supported yet");
-            const method = ts.isMethodDeclaration(member) ? name : `${ts.isGetAccessor(member) ? "get" : "set"}:${name}`;
+            const method = ts.isMethodDeclaration(member)
+                ? name
+                : `${ts.isGetAccessor(member) ? "get" : "set"}:${name}`;
             const value = classMethodValue(lowerer, info.decl, info, method, loc);
             if (!value || !lowerer.dynConvertible(value.type))
                 return refuse("prototype reflection with a member that cannot cross a checked value boundary is not supported yet");
-            const key = ts.isComputedPropertyName(member.name) ? lowerer.lowerExpr(member.name.expression)
+            const key = ts.isComputedPropertyName(member.name)
+                ? lowerer.lowerExpr(member.name.expression)
                 : { kind: "strLit", value: member.name.text, type: STRING, loc };
-            initialization.then.push(define(key, ts.isMethodDeclaration(member) ? [{ key: "value", value }, writable]
+            initialization.then.push(define(key, ts.isMethodDeclaration(member)
+                ? [{ key: "value", value }, writable]
                 : [{ key: ts.isGetAccessor(member) ? "get" : "set", value }]));
         }
     }
@@ -162,9 +307,12 @@ export function reflectClassPrototype(lowerer, info, loc, receiver) {
     return prototype;
 }
 export function isCompiledPrototypeMember(lowerer, info, name) {
-    return name === "constructor" || name === "__proto__" ||
-        !!findMethodOn(lowerer, info, name) || !!findGenericMethodOn(lowerer, info, name) ||
-        !!findMethodOn(lowerer, info, `get:${name}`) || !!findMethodOn(lowerer, info, `set:${name}`);
+    return (name === "constructor" ||
+        name === "__proto__" ||
+        !!findMethodOn(lowerer, info, name) ||
+        !!findGenericMethodOn(lowerer, info, name) ||
+        !!findMethodOn(lowerer, info, `get:${name}`) ||
+        !!findMethodOn(lowerer, info, `set:${name}`));
 }
 /** Named data and method slots have native descriptors. Bare reflection and
  * accessor replacement still require a complete view of the prototype. */
@@ -177,21 +325,32 @@ export function lowerClassPrototypeData(lowerer, expr) {
     if (!info)
         return null;
     const parent = expr.parent;
-    const descriptorKey = ts.isCallExpression(parent) && parent.arguments[0] === expr &&
-        ts.isPropertyAccessExpression(parent.expression) && lowerer.stdlibGlobalMember(parent.expression, "Object") === "defineProperty" &&
-        parent.arguments[1] && ts.isStringLiteral(parent.arguments[1]) ? parent.arguments[1].text : null;
-    const name = ts.isPropertyAccessExpression(parent) && parent.expression === expr ? parent.name.text
-        : ts.isElementAccessExpression(parent) && parent.expression === expr && parent.argumentExpression && ts.isStringLiteral(parent.argumentExpression)
-            ? parent.argumentExpression.text : descriptorKey;
+    const descriptorKey = ts.isCallExpression(parent) &&
+        parent.arguments[0] === expr &&
+        ts.isPropertyAccessExpression(parent.expression) &&
+        lowerer.stdlibGlobalMember(parent.expression, "Object") === "defineProperty" &&
+        parent.arguments[1] &&
+        ts.isStringLiteral(parent.arguments[1])
+        ? parent.arguments[1].text
+        : null;
+    const name = ts.isPropertyAccessExpression(parent) && parent.expression === expr
+        ? parent.name.text
+        : ts.isElementAccessExpression(parent) &&
+            parent.expression === expr &&
+            parent.argumentExpression &&
+            ts.isStringLiteral(parent.argumentExpression)
+            ? parent.argumentExpression.text
+            : descriptorKey;
     const method = name !== null && lowerer.prototypeMethodAccesses.has(name) && findMethodOn(lowerer, info, name);
     if (name === "constructor") {
         return reflectClassPrototype(lowerer, info, locOf(expr), classValueRef(lowerer, info, expr));
     }
-    if (name === null || isCompiledPrototypeMember(lowerer, info, name) && !method) {
+    if (name === null || (isCompiledPrototypeMember(lowerer, info, name) && !method)) {
         lowerer.unsupported("SC1090", expr, "class prototype reflection and accessor replacement (named prototype data and methods compile)");
     }
     const value = classPrototypeData(lowerer, info, locOf(expr), info.localClass
-        ? lowerer.lowerExprExpecting(expr.expression, { kind: "classval", className: info.def.name }) : undefined);
+        ? lowerer.lowerExprExpecting(expr.expression, { kind: "classval", className: info.def.name })
+        : undefined);
     if (value === null)
         lowerer.unsupported("SC1090", expr, "prototype data on local, generic, mixin, or runtime-provided classes");
     return value;
@@ -210,16 +369,33 @@ export function lowerClassPrototypeAssign(lowerer, call) {
     }
     const loc = locOf(call);
     const value = classPrototypeData(lowerer, info, loc, info.localClass
-        ? lowerer.lowerExprExpecting(target.expression, { kind: "classval", className: info.def.name }) : undefined);
+        ? lowerer.lowerExprExpecting(target.expression, {
+            kind: "classval",
+            className: info.def.name,
+        })
+        : undefined);
     if (!value)
         lowerer.unsupported("SC1090", target, "prototype data on generic, mixin, or runtime-provided classes");
     const sources = call.arguments.slice(1).map((node) => lowerer.lowerExprExpecting(node, DYN));
-    return { kind: "libCall", fn: "dyn.assignPrototype", args: [value,
-            { kind: "dynArrLit", elems: sources, type: DYN, loc }, prototypeProtectedKeys(lowerer, info, target, loc),
-        ], type: DYN, loc };
+    return {
+        kind: "libCall",
+        fn: "dyn.assignPrototype",
+        args: [
+            value,
+            { kind: "dynArrLit", elems: sources, type: DYN, loc },
+            prototypeProtectedKeys(lowerer, info, target, loc),
+        ],
+        type: DYN,
+        loc,
+    };
 }
 function prototypeProtectedKeys(lowerer, info, target, loc) {
-    const keys = ["constructor", "__proto__"].map((name) => ({ kind: "strLit", value: name, type: STRING, loc }));
+    const keys = ["constructor", "__proto__"].map((name) => ({
+        kind: "strLit",
+        value: name,
+        type: STRING,
+        loc,
+    }));
     for (let owner = info; owner; owner = owner.base) {
         const methodNames = new Set([...owner.methods.keys()]);
         if (owner.genericMethods)
@@ -233,13 +409,21 @@ function prototypeProtectedKeys(lowerer, info, target, loc) {
             if (owner.builtinError && name === "toString")
                 continue;
             if (name.startsWith("sym:")) {
-                keys.push({ kind: "libCall", fn: "sym.wellKnown", args: [{ kind: "strLit", value: name.slice(4), type: STRING, loc }], type: SYMBOL_T, loc });
+                keys.push({
+                    kind: "libCall",
+                    fn: "sym.wellKnown",
+                    args: [{ kind: "strLit", value: name.slice(4), type: STRING, loc }],
+                    type: SYMBOL_T,
+                    loc,
+                });
             }
             else if (name.startsWith("%symbol:")) {
                 const entries = owner.symbolMethods ? [...owner.symbolMethods] : [];
                 const entry = entries.find(([, field]) => field === name);
                 const declaration = entry ? lowerer.checker.valueDeclarationOf(entry[0]) : undefined;
-                if (!declaration || !ts.isVariableDeclaration(declaration) || !ts.isIdentifier(declaration.name))
+                if (!declaration ||
+                    !ts.isVariableDeclaration(declaration) ||
+                    !ts.isIdentifier(declaration.name))
                     lowerer.unsupported("SC1090", target, "prototype mutation with unresolved symbol methods");
                 keys.push(lowerer.lowerExpr(declaration.name));
             }
@@ -247,13 +431,19 @@ function prototypeProtectedKeys(lowerer, info, target, loc) {
                 keys.push({ kind: "strLit", value: name.replace(/^(get|set):/, ""), type: STRING, loc });
         }
     }
-    return { kind: "dynArrLit", elems: keys.map((key) => key.type.kind === "dyn" ? key : { kind: "dynFrom", value: key, type: DYN, loc }), type: DYN, loc };
+    return {
+        kind: "dynArrLit",
+        elems: keys.map((key) => key.type.kind === "dyn" ? key : { kind: "dynFrom", value: key, type: DYN, loc }),
+        type: DYN,
+        loc,
+    };
 }
 /** Computed additions share the prototype bag without exposing or replacing
  * native method slots. Preserve reference/RHS evaluation and assignment value. */
 export function lowerClassPrototypeComputedAssignment(lowerer, expr) {
     const target = expr.left;
-    if (!ts.isElementAccessExpression(target) || !ts.isPropertyAccessExpression(target.expression) ||
+    if (!ts.isElementAccessExpression(target) ||
+        !ts.isPropertyAccessExpression(target.expression) ||
         target.expression.name.text !== "prototype")
         return null;
     const prototypeNode = target.expression;
@@ -262,40 +452,109 @@ export function lowerClassPrototypeComputedAssignment(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     const prototype = classPrototypeData(lowerer, info, loc, info.localClass
-        ? lowerer.lowerExprExpecting(prototypeNode.expression, { kind: "classval", className: info.def.name }) : undefined);
+        ? lowerer.lowerExprExpecting(prototypeNode.expression, {
+            kind: "classval",
+            className: info.def.name,
+        })
+        : undefined);
     if (!prototype)
         lowerer.unsupported("SC1090", target, "prototype data on generic, mixin, or runtime-provided classes");
     const receiver = lowerer.declareHiddenLocal("%prototypeReceiver", DYN);
     const key = lowerer.declareHiddenLocal("%prototypeKey", DYN);
     const raw = lowerer.lowerExpr(expr.right);
-    const value = raw.type.kind === "void" ? { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: raw, loc }],
-        result: dynUndefinedExpr(loc), type: DYN, loc }
-        : isUnitType(raw.type) ? lowerer.coerceInto(expr.right, raw, DYN) : raw;
+    const value = raw.type.kind === "void"
+        ? {
+            kind: "seqExpr",
+            stmts: [{ kind: "exprStmt", expr: raw, loc }],
+            result: dynUndefinedExpr(loc),
+            type: DYN,
+            loc,
+        }
+        : isUnitType(raw.type)
+            ? lowerer.coerceInto(expr.right, raw, DYN)
+            : raw;
     const assigned = lowerer.declareHiddenLocal("%prototypeValue", value.type);
     const result = varRef(assigned.id, value.type, loc);
-    return { kind: "seqExpr", stmts: [
+    return {
+        kind: "seqExpr",
+        stmts: [
             { kind: "varDecl", localId: receiver.id, init: prototype, loc },
-            { kind: "varDecl", localId: key.id, init: lowerer.lowerExprExpecting(target.argumentExpression, DYN), loc },
+            {
+                kind: "varDecl",
+                localId: key.id,
+                init: lowerer.lowerExprExpecting(target.argumentExpression, DYN),
+                loc,
+            },
             { kind: "varDecl", localId: assigned.id, init: value, loc },
-            { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.assignPrototype", args: [varRef(receiver.id, DYN, loc),
-                        { kind: "dynArrLit", elems: [{ kind: "dynObjLit", fields: [{ key: varRef(key.id, DYN, loc), value: lowerer.coerceInto(expr.right, result, DYN) }], type: DYN, loc }], type: DYN, loc },
-                        prototypeProtectedKeys(lowerer, info, prototypeNode, loc)], type: DYN, loc }, loc },
-        ], result, type: result.type, loc };
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "dyn.assignPrototype",
+                    args: [
+                        varRef(receiver.id, DYN, loc),
+                        {
+                            kind: "dynArrLit",
+                            elems: [
+                                {
+                                    kind: "dynObjLit",
+                                    fields: [
+                                        {
+                                            key: varRef(key.id, DYN, loc),
+                                            value: lowerer.coerceInto(expr.right, result, DYN),
+                                        },
+                                    ],
+                                    type: DYN,
+                                    loc,
+                                },
+                            ],
+                            type: DYN,
+                            loc,
+                        },
+                        prototypeProtectedKeys(lowerer, info, prototypeNode, loc),
+                    ],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        result,
+        type: result.type,
+        loc,
+    };
 }
 export function lowerClassPrototypeDescriptors(lowerer, call, member) {
     const target = call.arguments[0];
-    if (member !== "defineProperties" || call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement) ||
-        !target || !ts.isPropertyAccessExpression(target) || target.name.text !== "prototype")
+    if (member !== "defineProperties" ||
+        call.arguments.length !== 2 ||
+        call.arguments.some(ts.isSpreadElement) ||
+        !target ||
+        !ts.isPropertyAccessExpression(target) ||
+        target.name.text !== "prototype")
         return null;
     const info = exactClassOfReceiver(lowerer, target.expression);
     if (!info)
         return null;
     const loc = locOf(call);
     const prototype = classPrototypeData(lowerer, info, loc, info.localClass
-        ? lowerer.lowerExprExpecting(target.expression, { kind: "classval", className: info.def.name }) : undefined);
+        ? lowerer.lowerExprExpecting(target.expression, {
+            kind: "classval",
+            className: info.def.name,
+        })
+        : undefined);
     if (!prototype)
         lowerer.unsupported("SC1090", target, "prototype data on generic, mixin, or runtime-provided classes");
-    return { kind: "libCall", fn: "dyn.definePrototypeProps", args: [prototype,
-            lowerer.lowerExprExpecting(call.arguments[1], DYN), prototypeProtectedKeys(lowerer, info, target, loc)], type: DYN, loc };
+    return {
+        kind: "libCall",
+        fn: "dyn.definePrototypeProps",
+        args: [
+            prototype,
+            lowerer.lowerExprExpecting(call.arguments[1], DYN),
+            prototypeProtectedKeys(lowerer, info, target, loc),
+        ],
+        type: DYN,
+        loc,
+    };
 }
 //# sourceMappingURL=class-prototypes.js.map