@scriptc/compiler 0.3.6 → 0.4.1

package/dist/backend/llvm/expr-calls.js

@@ -1,15 +1,15 @@
 /* Focused LLVM expression emission extracted from emitter.ts. */
 import { InternalCompilerError } from "../../errors.js";
 import { newValueMayThrow } from "../../ir/analysis.js";
-import { isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, typeKey, } from "../../ir/ir.js";
+import { isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, typeKey, classValueConstructor, } from "../../ir/ir.js";
 import { liveRefView } from "./expr-stream-bridges.js";
 import { typedRefConstructor, vAdapters } from "./shapes.js";
 import { INT32_ABI_SUFFIX, SCALAR_UNION_RESULT } from "./int32-abi.js";
 import { dispatchesCall, INTEGER_DISPATCH_SUFFIX } from "./integer-clones.js";
 import { canStackObject, emitStackObject } from "./stack-objects.js";
 import { collectFfiRetainedOps, parseFfiCallbackKey } from "../ffi-callbacks.js";
-import { mangleAsyncAdoptCall, mangleAsyncAwaitCall, mangleBorrowedFunction, mangleBorrowingWrapper, mangleClassNew, mangleClassRetain, mangleClassStruct, mangleFnClosure, mangleFunction, mangleWrapper, mangleVtStruct, } from "../mangle.js";
-import { classMembershipIntervals, classEnvironmentIndex, classStructSym, vtEntriesFor, } from "./classes.js";
+import { mangleAsyncAdoptCall, mangleAsyncAwaitCall, mangleAsyncInlineAwaitCall, mangleBorrowedFunction, mangleBorrowingWrapper, mangleClassNew, mangleClassRetain, mangleClassStruct, mangleFnClosure, mangleFunction, mangleWrapper, mangleVtStruct, } from "../mangle.js";
+import { classEnvironmentIndex, classIdVtLines, classStructSym, vtEntriesFor, } from "./classes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl } from "./common.js";
 import { canStackUnion, emitStackUnion } from "./stack-unions.js";
@@ -17,6 +17,8 @@ import { emitCallArrayRead } from "./local-array-reads.js";
 import { emitScalarOptional, isScalarOptionalSource } from "./local-union-storage.js";
 import { emitStackMapRead } from "./map-read-lifetimes.js";
 import { borrowableInputs, emitBorrowedInput, emitBorrowedInputs, inputSuffixWrites, } from "./borrowed-inputs.js";
+import { emitJsIcCall, jsIcSiteOf } from "./js-ic.js";
+import { emitClassMembership, emitDowncastGuard } from "./narrow-guards.js";
 export function emitCallExpr(host, e, awaitEntry = false, 
 /** A projection consumes a scalar union result (Int32Abi.union): answer
  * a private stack box instead of a heap box. */
@@ -32,6 +34,13 @@ plainCall = false) {
             const callee = host.fnByName.get(e.callee);
             if (!callee)
                 throw new InternalCompilerError(`llvm emitter bug: unknown callee ${e.callee}`);
+            if (!plainCall && !awaitEntry && !resultSlot && !stackResult) {
+                // A property helper called from dynamic-tier code is an inline
+                // cache site (two-tier design S4).
+                const site = jsIcSiteOf(host, e);
+                if (site)
+                    return emitJsIcCall(host, e, callee, site);
+            }
             if (callee.fastRead === "index" && !plainCall && !awaitEntry && !resultSlot) {
                 const indexed = emitNumericIndexRead(host, e, callee);
                 if (indexed)
@@ -85,7 +94,10 @@ plainCall = false) {
                         if (a.kind === "call" && host.scalarResultCall(a))
                             return emitCallExpr(host, a, false, true);
                         if (host.stackObjects && canStackObject(host, a))
-                            return emitStackObject(host, a);
+                            return emitStackObject(host, a, (fields) => {
+                                for (const field of fields)
+                                    host.ownSlot(field.ptr, field.type);
+                            });
                         if (host.nullableFieldGet(a))
                             return { name: host.emitOwnedNullableStack(a).box, type: a.type };
                         // An inline union field read copies its tag and bits.
@@ -104,7 +116,7 @@ plainCall = false) {
             // source, and releases earlier arguments if evaluation throws.
             args.forEach((a, index) => {
                 if (!borrowed?.has(index))
-                    host.moveTemp(a);
+                    host.toFrame(a);
             });
             const abi = awaitEntry ? undefined : host.int32Abis.get(e.callee);
             const argList = args
@@ -112,6 +124,21 @@ plainCall = false) {
                 ? `i32 ${host.int32Argument(a, e.args[i])}`
                 : `${host.llType(callee.params[i].type)} ${a.name}`)
                 .join(", ");
+            if (awaitEntry === "inline") {
+                // A stackless coroutine's await of a fiberless callee: the entry
+                // runs the body in place and leaves a throw pending; the enclosing
+                // await takes the turn and tests (emitCoroInlineAwait).
+                host.inlineAwaitCallees.add(e.callee);
+                const awaited = callee.returnType;
+                const entry = `@${mangleAsyncInlineAwaitCall(e.callee)}`;
+                if (awaited.kind === "void") {
+                    B.line(`call void ${entry}(${argList})`);
+                    return { name: "", type: awaited };
+                }
+                const t = B.tmp();
+                B.line(`${t} = call ${host.llType(awaited)} ${entry}(${argList})`);
+                return host.own({ name: t, type: awaited });
+            }
             if (awaitEntry) {
                 // The enclosing await routes this call through the callee's
                 // await-call entry: the result is the awaited value, and the
@@ -148,7 +175,7 @@ plainCall = false) {
                 if (host.mayThrow.has(e.callee))
                     host.emitPendingCheck();
                 if (borrowed)
-                    host.releaseFrame(host.frames.pop());
+                    host.releaseTemps(host.frames.pop());
                 return { name: "", type: e.type };
             }
             const t = B.tmp();
@@ -157,7 +184,7 @@ plainCall = false) {
                 if (host.mayThrow.has(e.callee))
                     host.emitPendingCheck();
                 if (borrowed)
-                    host.releaseFrame(host.frames.pop());
+                    host.releaseTemps(host.frames.pop());
                 if (stackResult)
                     return host.stackScalarUnion(t, e.type);
                 return host.own({ name: host.boxScalarUnion(t, e.type), type: e.type });
@@ -168,7 +195,7 @@ plainCall = false) {
                 if (host.mayThrow.has(e.callee))
                     host.emitPendingCheck(out);
                 if (borrowed)
-                    host.releaseFrame(host.frames.pop());
+                    host.releaseTemps(host.frames.pop());
                 return out;
             }
             B.line(`${t} = call ${host.llType(e.type)} ${target}(${argList})`);
@@ -179,7 +206,7 @@ plainCall = false) {
                 // argument snapshots that keep it reachable are released.
                 if (host.mayThrow.has(e.callee))
                     host.emitPendingCheck();
-                out = host.own({ name: host.retainValue(t, e.type), type: e.type });
+                out = host.own({ name: host.retainFrame(t, e.type), type: e.type });
             }
             else {
                 out = host.own({ name: t, type: e.type });
@@ -187,8 +214,8 @@ plainCall = false) {
                     host.emitPendingCheck(out);
             }
             if (borrowed) {
-                host.moveTemp(out);
-                host.releaseFrame(host.frames.pop());
+                host.toFrame(out);
+                host.releaseTemps(host.frames.pop());
                 return host.own(out);
             }
             return out;
@@ -263,6 +290,16 @@ plainCall = false) {
                             natArgs.push(`ptr ${data}`, `${host.sizeType} ${len}`);
                             break;
                         }
+                        case "cstring": {
+                            // The string's own NUL-terminated data, after the check that
+                            // it holds no U+0000 (a C string cannot carry one).
+                            host.declare(`declare ptr @scr_library_cstr_arg(ptr)`);
+                            const data = B.tmp();
+                            B.line(`${data} = call ptr @scr_library_cstr_arg(ptr ${arg.name})`);
+                            natTypes.push("ptr");
+                            natArgs.push(`ptr ${data}`);
+                            break;
+                        }
                         case "bytes": {
                             const lenPtr = B.tmp();
                             const len = B.tmp();
@@ -614,7 +651,7 @@ plainCall = false) {
                 // every mention yields the same pointer, so `f === f` is true.
                 host.fnValues.add(e.fnName);
                 return host.own({
-                    name: host.retainValue(`@${mangleFnClosure(e.fnName)}`, e.type),
+                    name: host.retainFrame(`@${mangleFnClosure(e.fnName)}`, e.type),
                     type: e.type,
                 });
             }
@@ -768,7 +805,7 @@ plainCall = false) {
             const args = e.args.map((a, i) => lent?.has(i) && lend[i] ? host.emitReadReceiver(a) : host.emitExpr(a));
             args.forEach((a, i) => {
                 if (!lent?.has(i))
-                    host.moveTemp(a);
+                    host.toFrame(a);
             });
             const argListOf = (values) => [
                 `ptr ${callee.name}`,
@@ -776,7 +813,7 @@ plainCall = false) {
             ].join(", ");
             // The owned entry consumes a reference of each lent argument.
             const ownedArgs = () => lent
-                ? args.map((a, i) => lent.has(i) ? { name: host.retainValue(a.name, a.type), type: a.type } : a)
+                ? args.map((a, i) => lent.has(i) ? { name: host.retainFrame(a.name, a.type), type: a.type } : a)
                 : args;
             const invoke = (target, needsReceiver, values = args) => {
                 if (needsReceiver) {
@@ -850,7 +887,7 @@ plainCall = false) {
                 if (host.indirectMayThrow)
                     host.emitPendingCheck();
                 if (lent)
-                    host.releaseFrame(host.frames.pop());
+                    host.releaseTemps(host.frames.pop());
                 return { name: "", type: e.type };
             }
             // The check runs AFTER the result temp joins the frame: an unwind
@@ -859,15 +896,15 @@ plainCall = false) {
             if (host.indirectMayThrow)
                 host.emitPendingCheck();
             if (lent) {
-                host.moveTemp(out);
-                host.releaseFrame(host.frames.pop());
+                host.toFrame(out);
+                host.releaseTemps(host.frames.pop());
                 return host.own(out);
             }
             return out;
         }
         case "selfRef":
             // The running closure itself (env is borrowed; the result owned).
-            return host.own({ name: host.retainValue("%sc_env", e.type), type: e.type });
+            return host.own({ name: host.retainFrame("%sc_env", e.type), type: e.type });
         case "new": {
             // Allocate (fields zeroed, vt stamped), then run the ctor. The
             // ctor owns and releases its `this` param like any callee, so it
@@ -903,7 +940,7 @@ plainCall = false) {
                 });
                 return host.own({ name: value, type: e.type });
             }
-            return host.own({ name: host.retainValue(`@${sym}`, e.type), type: e.type });
+            return host.own({ name: host.retainFrame(`@${sym}`, e.type), type: e.type });
         }
         case "newValue": {
             // Construction through a class VALUE: call the class object's
@@ -912,19 +949,20 @@ plainCall = false) {
             if (e.callee.type.kind !== "classval")
                 throw new InternalCompilerError("llvm emitter bug: newValue on non-classval callee");
             const cls = e.callee.type.className;
-            const ctor = host.fnByName.get(`%${cls}.constructor`);
+            const valueCtor = classValueConstructor(host.classMetaOf(cls).def);
+            const ctor = host.fnByName.get(valueCtor.fn);
             if (!ctor)
                 throw new InternalCompilerError(`llvm emitter bug: newValue on ${cls} without a constructor`);
             const callee = host.emitExpr(e.callee);
             const args = e.args.map((a) => host.emitExpr(a));
             for (const a of args)
-                host.moveTemp(a); // the constructor owns its params
+                host.toFrame(a); // the constructor owns its params
             const ctorp = B.tmp();
             const thunk = B.tmp();
             B.line(`${ctorp} = getelementptr inbounds %ScrClassObj, ptr ${callee.name}, i64 0, i32 3`);
             B.line(`${thunk} = load ptr, ptr ${ctorp}`);
             const argList = args
-                .map((a, i) => `${host.llType(ctor.params[i + 1].type)} ${a.name}`)
+                .map((a, i) => `${host.llType(ctor.params[i + valueCtor.firstArg].type)} ${a.name}`)
                 .join(", ");
             const t = B.tmp();
             B.line(`${t} = call ptr ${thunk}(ptr ${callee.name}${argList ? ", " + argList : ""})`);
@@ -981,7 +1019,7 @@ plainCall = false) {
             // One ScrPromise* either way — ownership transfers, type-only
             //.
             const v = host.emitExpr(e.value);
-            host.moveTemp(v);
+            host.toFrame(v);
             return host.own({ name: v.name, type: e.type });
         }
         case "upcast":
@@ -989,10 +1027,13 @@ plainCall = false) {
             // Prefix layout: both directions are reinterprets of the SAME
             // pointer — no RC traffic, ownership transfers from the operand
             // temp to the result temp (struck so the one +1 releases exactly
-            // once, under the RESULT type's release).
+            // once, under the RESULT type's release). A downcast verifies the
+            // class tsc's narrowing proved (narrow-guards.ts).
             const v = host.emitExpr(e.value);
+            if (e.kind === "downcast" && e.type.kind === "object" && v.type.kind === "object")
+                emitDowncastGuard(host, v.name, v.type.className, e.type.className);
             if (isRefCounted(v.type))
-                host.moveTemp(v);
+                host.toFrame(v);
             return host.own({ name: v.name, type: e.type });
         }
         case "instanceOf": {
@@ -1003,22 +1044,7 @@ plainCall = false) {
             // The test only reads the vtable word: a borrowable operand needs no
             // retain/release pair around it.
             const v = emitBorrowedInputs(host, [e.value])[0];
-            const target = host.classMetaOf(e.className);
-            const pre = host.loadVtPre(v.name, e.value.type.className);
-            let result;
-            for (const interval of classMembershipIntervals(host.classMeta, target.def.name)) {
-                const ge = B.tmp(), le = B.tmp(), test = B.tmp();
-                B.line(`${ge} = icmp uge ${host.sizeType} ${pre}, ${interval.pre}`);
-                B.line(`${le} = icmp ule ${host.sizeType} ${pre}, ${interval.post}`);
-                B.line(`${test} = and i1 ${ge}, ${le} ; instanceof ${e.className}`);
-                if (result === undefined)
-                    result = test;
-                else {
-                    const combined = B.tmp();
-                    B.line(`${combined} = or i1 ${result}, ${test}`);
-                    result = combined;
-                }
-            }
+            const result = emitClassMembership(host, v.name, e.value.type.className, e.className, `instanceof ${e.className}`);
             return { name: result, type: e.type };
         }
         case "virtualCall": {
@@ -1044,16 +1070,21 @@ plainCall = false) {
             const args = e.args.map((a, index) => borrowed.has(index) && inputs[index] ? host.emitReadReceiver(a) : host.emitExpr(a));
             args.forEach((a, index) => {
                 if (!borrowed.has(index))
-                    host.moveTemp(a);
+                    host.toFrame(a);
             });
             const recv = args[0].name;
-            const vtp = B.tmp();
             const vt = B.tmp();
             const fnp = B.tmp();
             const fn = B.tmp();
-            B.line(`${vtp} = getelementptr inbounds %${classStructSym(e.className)}, ptr ${recv}, i64 0, i32 1`);
             // Set once at allocation (classes.ts launders each new object).
-            B.line(`${vt} = load ptr, ptr ${vtp}, !invariant.group !{}`);
+            if (meta.idInRc)
+                for (const line of classIdVtLines(meta, recv, vt, ", !invariant.group !{}"))
+                    B.line(line.trimStart());
+            else {
+                const vtp = B.tmp();
+                B.line(`${vtp} = getelementptr inbounds %${classStructSym(e.className)}, ptr ${recv}, i64 0, i32 1`);
+                B.line(`${vt} = load ptr, ptr ${vtp}, !invariant.group !{}`);
+            }
             B.line(`${fnp} = getelementptr inbounds %${mangleVtStruct(meta.root.def.name)}, ptr ${vt}, i64 0, i32 ${slotIdx + 1}`);
             B.line(`${fn} = load ptr, ptr ${fnp} ; ${e.method}`);
             const argList = args
@@ -1094,7 +1125,7 @@ plainCall = false) {
                     if (host.mayThrowMethods.has(e.method))
                         host.emitPendingCheck();
                     if (borrowed.size > 0)
-                        host.releaseFrame(host.frames.pop());
+                        host.releaseTemps(host.frames.pop());
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
@@ -1103,8 +1134,8 @@ plainCall = false) {
                 if (host.mayThrowMethods.has(e.method))
                     host.emitPendingCheck();
                 if (borrowed.size > 0) {
-                    host.moveTemp(out);
-                    host.releaseFrame(host.frames.pop());
+                    host.toFrame(out);
+                    host.releaseTemps(host.frames.pop());
                     return host.own(out);
                 }
                 return out;
@@ -1114,7 +1145,7 @@ plainCall = false) {
                 if (host.mayThrowMethods.has(e.method))
                     host.emitPendingCheck();
                 if (borrowed.size > 0)
-                    host.releaseFrame(host.frames.pop());
+                    host.releaseTemps(host.frames.pop());
                 return { name: "", type: e.type };
             }
             const t = B.tmp();
@@ -1123,8 +1154,8 @@ plainCall = false) {
             if (host.mayThrowMethods.has(e.method))
                 host.emitPendingCheck();
             if (borrowed.size > 0) {
-                host.moveTemp(out);
-                host.releaseFrame(host.frames.pop());
+                host.toFrame(out);
+                host.releaseTemps(host.frames.pop());
                 return host.own(out);
             }
             return out;
@@ -1226,7 +1257,7 @@ export function emitConstruction(host, e, o, ctor) {
         });
         args.forEach((a, i) => {
             if (!borrowed.has(i + 1))
-                host.moveTemp(a);
+                host.toFrame(a);
         });
         const self = borrowed.has(0)
             ? o
@@ -1239,12 +1270,12 @@ export function emitConstruction(host, e, o, ctor) {
         B.line(`call void @${mangleBorrowedFunction(ctorName)}${host.int32Abis.has(ctorName) ? INT32_ABI_SUFFIX : ""}(${argList})`);
         if (host.mayThrow.has(ctorName))
             host.emitPendingCheck();
-        host.releaseFrame(host.frames.pop());
+        host.releaseTemps(host.frames.pop());
         return;
     }
     const args = e.args.map((a) => host.emitExpr(a));
     for (const a of args)
-        host.moveTemp(a);
+        host.toFrame(a);
     const r = B.tmp();
     B.line(`${r} = call ptr @${mangleClassRetain(e.className)}(ptr ${o})`);
     const argList = [`ptr ${r}`, ...ctorArguments(host, ctorName, ctor, args, e.args)].join(", ");
@@ -1284,8 +1315,8 @@ function emitNumericIndexRead(host, e, callee) {
     B.startBlock(slow);
     host.frames.push([]);
     const read = emitCallExpr(host, e, false, false, undefined, true);
-    host.moveTemp(read);
-    host.releaseFrame(host.frames.pop());
+    host.toFrame(read);
+    host.releaseTemps(host.frames.pop());
     const slowLabel = B.currentLabel();
     B.terminate(`br label %${join}`);
     B.startBlock(join);