@scriptc/compiler 0.2.6 → 0.2.7

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

@@ -164,6 +164,8 @@ export interface ClassInfo {
     staticFields: {
         name: string;
         type: IrType;
+        /** Indexed sources can be absent despite the declared static type. */
+        runtimeOptional?: true;
         initializer: ts.Expression;
         globalId: string;
         readonly: boolean;

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

@@ -1,4 +1,5 @@
 import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
+import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
  * (fields, methods, accessors, overrides), constructor/member lowering with
@@ -380,6 +381,10 @@ export function registerBuiltinErrorClasses(lowerer) {
                     { name: "%nameEnumerable", type: BOOL },
                     { name: "%stackFrames", type: STRING },
                     { name: "%stack", type: STRING },
+                    { name: "%systemErrno", type: F64 },
+                    { name: "%systemCall", type: STRING },
+                    { name: "%systemPath", type: STRING },
+                    { name: "%systemDest", type: STRING },
                 ],
                 loc,
             },
@@ -1883,8 +1888,8 @@ mixin) {
                 // declaration is an ordinary OWN field (tsc guarantees every
                 // instantiable subclass declares it and, under
                 // strictPropertyInitialization, initializes it). Reads through
-                // ABSTRACT-typed receivers have no slot to read and keep a
-                // per-site fence.
+                // ABSTRACT-typed receivers resolve the concrete instance's
+                // property through checked class dispatch.
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword))
                     continue;
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)) {
@@ -2234,15 +2239,12 @@ mixin) {
                     if (findGenericMethodOn(lowerer, base, mName)) {
                         lowerer.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
                     }
-                    // Abstract re-declarations keep the overridden ABI exactly,
-                    // like any override (a concrete implementation below must
-                    // agree with BOTH, which exactness makes one constraint).
                     const overridden = lowerer.findMethodOn(base, mName);
                     if (overridden &&
                         (overridden.sig.params.length !== shapes.length ||
                             !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                            !typeEquals(overridden.sig.ret, ret))) {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                            !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ret, overridden.sig.ret, className, base)))) {
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                     methods.set(mName, { params: shapes, ret, abstract: true });
                     continue;
@@ -2363,11 +2365,12 @@ mixin) {
                     if (refined)
                         ft.ret = refined;
                 }
-                // Overrides keep the EXACT overridden ABI signature. tsc's method
+                // Overrides keep the inherited ABI signature. tsc's method
                 // bivariance would let a narrowed parameter type through, and a
                 // vtable-dispatched call could then hand the override a base
                 // instance it reads out-of-bounds fields from — exactness keeps
-                // every slot sound (covariant returns can come later). Comparing
+                // every parameter slot sound. Nominal covariant returns share the
+                // base pointer ABI while retaining their declared result type. Comparing
                 // ABI types only (not modes) is deliberate: call sites complete
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
@@ -2429,7 +2432,7 @@ mixin) {
                     member.asteriskToken === undefined &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                        !typeEquals(overridden.sig.ret, ft.ret))) {
+                        !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ft.ret, overridden.sig.ret, className, base)))) {
                     const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
                         overridden.declarer.decl !== null &&
                         isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
@@ -2456,12 +2459,12 @@ mixin) {
                             });
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), returnOnly
                             ? `overriding method '${mName}' with a different return type (the native return type must match the base declaration exactly)`
-                            : `overriding method '${mName}' with a different signature (the native parameter and return types must match the base declaration exactly)`));
+                            : `overriding method '${mName}' with a different signature (the native parameter types must match the base declaration exactly; returns may narrow to a subclass)`));
                         shapes.splice(0, shapes.length, ...overridden.sig.params);
                         ft.ret = overridden.sig.ret;
                     }
                     else {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                 }
                 const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
@@ -3939,7 +3942,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' 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 (found?.field !== undefined) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     if (found) {
         return staticMethodValue(lowerer, found.declarer, expr.name.text, found.method, expr, loc);
@@ -4752,7 +4761,13 @@ export function lowerClassValueProperty(lowerer, expr) {
         lowerer.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)`);
     }
     if (found.field !== undefined) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     return staticMethodValue(lowerer, found.declarer, member, found.method, expr, loc);
 }
@@ -4770,6 +4785,20 @@ function abstractMemberSignature(lowerer, member) {
         ret: lowerer.declaredReturnType(member, member.name),
     };
 }
+/** A nominal return subtype uses the same owned pointer as the inherited
+ * return slot. The current class is still being collected, so consult its
+ * already collected base chain before the complete class graph is available. */
+function overrideReturnAbi(lowerer, declared, inherited, className, base) {
+    if (declared.kind !== "object" || inherited.kind !== "object")
+        return declared;
+    if (lowerer.isSubclassOf(declared.className, inherited.className) ||
+        (declared.className === className &&
+            base !== null &&
+            (base.def.name === inherited.className ||
+                lowerer.isSubclassOf(base.def.name, inherited.className))))
+        return inherited;
+    return declared;
+}
 /** The nearest declaration of `name` at or above `info` — the method a
  * receiver of that static class runs when nothing below overrides it. */
 export function findMethodOn(lowerer, info, name) {
@@ -4933,34 +4962,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
  * hierarchy identifies the original declarations through aliases as well. */
 export function collectVirtualJsMethods(lowerer, files) {
     const families = [];
-    // Record named prototype accesses before collecting method signatures.
-    // Those slots need a callable ABI even when JavaScript would otherwise
-    // specialize each call independently.
-    for (const file of files)
-        ts.walkPreorder(file, (node) => {
-            if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
-                return;
-            const name = ts.isPropertyAccessExpression(node)
-                ? node.name.text
-                : ts.isStringLiteralLike(node.argumentExpression)
-                    ? node.argumentExpression.text
-                    : null;
-            if (name === null)
-                return;
-            const prototype = ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "prototype";
-            const assigned = ts.isBinaryExpression(node.parent) &&
-                node.parent.left === node &&
-                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
-            const symbol = !assigned
-                ? undefined
-                : ts.isPropertyAccessExpression(node)
-                    ? lowerer.checker.getSymbolAtLocation(node.name)
-                    : lowerer.checker.getPropertyOfType(lowerer.typeOf(node.expression), name);
-            if (prototype ||
-                (symbol && lowerer.checker.declarationsOf(symbol).some(ts.isMethodDeclaration))) {
-                lowerer.prototypeMethodAccesses.set(name, node);
-            }
-        });
+    collectClassMethodMutations(lowerer, files);
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
             const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
@@ -7273,7 +7275,7 @@ export function lowerNew(lowerer, expr) {
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, ` +
-                    `arrays, promises, Maps, Sets, or unions of those — not functions, 'unknown', or 'any')`);
+                    `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }