@scriptc/compiler 0.2.2 → 0.2.4

package/dist/frontend/lowering/lower-system-errors.d.ts

@@ -0,0 +1,6 @@
+import type { Lowerer } from "./lowerer.js";
+import { type IrExpr, type SrcLoc } from "../../ir/ir.js";
+/** Build the native Map through the same checked entry conversion as
+ * new Map(iterable), so its values use the ordinary mutable tuple layout. */
+export declare function lowerSystemErrorMap(lowerer: Lowerer, loc: SrcLoc): IrExpr;
+export declare function lowerSystemErrorMapValue(lowerer: Lowerer, loc: SrcLoc): IrExpr;

package/dist/frontend/lowering/lower-system-errors.js

@@ -0,0 +1,29 @@
+import { DYN, F64, STRING } from "../../ir/ir.js";
+import { mapFromSeedValue } from "./lower-containers.js";
+import { InternalCompilerError } from "../../errors.js";
+/** Build the native Map through the same checked entry conversion as
+ * new Map(iterable), so its values use the ordinary mutable tuple layout. */
+export function lowerSystemErrorMap(lowerer, loc) {
+    const pair = { kind: "record", shapeId: lowerer.shapes.intern([
+            { name: "0", type: STRING }, { name: "1", type: STRING },
+        ], true) };
+    const map = { kind: "map", key: F64, value: pair };
+    const entries = { kind: "libCall", fn: "util.systemErrorEntries", args: [], type: DYN, loc };
+    const result = mapFromSeedValue(lowerer, entries, map);
+    if (!result)
+        throw new InternalCompilerError("system error entries must seed a native Map");
+    return result;
+}
+export function lowerSystemErrorMapValue(lowerer, loc) {
+    const key = "%builtin.util.getSystemErrorMap";
+    let name = lowerer.builtinCallableValueFns.get(key);
+    const result = lowerSystemErrorMap(lowerer, loc);
+    if (!name) {
+        name = key;
+        lowerer.builtinCallableValueFns.set(key, name);
+        lowerer.liftedFns.push({ name, params: [], returnType: result.type, locals: [],
+            body: [{ kind: "return", value: result, loc }], loc });
+    }
+    return { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [], ret: result.type }, loc };
+}
+//# sourceMappingURL=lower-system-errors.js.map

package/dist/frontend/lowering/lower-system-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-system-errors.js","sourceRoot":"","sources":["../../../src/frontend/lowering/lower-system-errors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAyC,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD;6EAC6E;AAC7E,MAAM,UAAU,mBAAmB,CAAC,OAAgB,EAAE,GAAW;IAC/D,MAAM,IAAI,GAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;YACpE,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE;SACzD,EAAE,IAAI,CAAC,EAAE,CAAC;IACX,MAAM,GAAG,GAA6B,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC7E,MAAM,OAAO,GAAW,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,yBAAyB,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IACrG,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACvD,IAAI,CAAC,MAAM;QAAE,MAAM,IAAI,qBAAqB,CAAC,6CAA6C,CAAC,CAAC;IAC5F,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,OAAgB,EAAE,GAAW;IACpE,MAAM,GAAG,GAAG,iCAAiC,CAAC;IAC9C,IAAI,IAAI,GAAG,OAAO,CAAC,uBAAuB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,mBAAmB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACjD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,IAAI,GAAG,GAAG,CAAC;QACX,OAAO,CAAC,uBAAuB,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;YAC5E,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC;AACpH,CAAC"}

package/dist/frontend/lowering/lowerer.d.ts

@@ -1927,9 +1927,10 @@ export declare class Lowerer {
     exactClassOfReceiver(expr: ts.Expression): ClassInfo | null;
     lowerClassMembers(info: ClassInfo): IrFunction[];
     lowerStaticFieldInits(info: ClassInfo): IrStmt[];
-    /** The method-like members (methods and accessors) of a class that have
-     * lowerable bodies, with their collected method-map names. */
-    classMethodMembers(info: ClassInfo): Generator<{
+    /** Method-like members with their collected method-map names. Body
+     * lowering omits abstract declarations; ABI analysis must include them
+     * because an abstract-typed call selects the same virtual slot. */
+    classMethodMembers(info: ClassInfo, includeAbstract?: boolean): Generator<{
         mName: string;
         member: ts.MethodDeclaration | ts.AccessorDeclaration;
     }>;

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,4 @@
-import { pathModuleValue } from "./lower-builtin-values.js";
+import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue } from "./lower-builtin-values.js";
 import { everyExprChild, everyStmtChild, transformStmtList } from "../../ir/traverse.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
 import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
@@ -33,7 +33,7 @@ import * as ts from "../ts7/adapter.js";
 import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
+import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
 import {} from "../npm.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
@@ -58,6 +58,7 @@ import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js"
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
 import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js";
 import { lowerUtilModuleCall } from "./lower-inspect.js";
+import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr } from "./lower-comptime.js";
 import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf } from "./lower-exprs.js";
@@ -2789,7 +2790,7 @@ export class Lowerer {
             });
         }
         for (const info of this.classes.values()) {
-            for (const { mName, member } of this.classMethodMembers(info)) {
+            for (const { mName, member } of this.classMethodMembers(info, true)) {
                 if (!member.name || !(ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)))
                     continue;
                 const symbol = symbolOf(member.name);
@@ -3459,21 +3460,32 @@ export class Lowerer {
                             }
                             return;
                         }
-                        const set = optionalParams.get(symbol) ?? new Set();
-                        shape.type = addUndefined(shape.type);
-                        const before = set.size;
-                        set.add(i);
-                        optionalParams.set(symbol, set);
-                        if (set.size !== before) {
-                            changed = true;
-                            const callee = functionDeclBySymbol.get(symbol);
-                            const parameter = callee?.parameters[i];
-                            if (parameter) {
-                                for (const bound of boundIdentifiersOf(parameter.name)) {
-                                    const boundSymbol = symbolOf(bound);
-                                    if (boundSymbol && !optionalSymbols.has(boundSymbol)) {
-                                        optionalSymbols.add(boundSymbol);
-                                        changed = true;
+                        // A virtual slot has one argument representation, even when
+                        // the unchecked read reaches only a base-typed call site.
+                        // Promote every implementation and its parameter bindings so
+                        // downstream calls and returns see the same optional value.
+                        const family = familyBySymbol.get(symbol);
+                        if (family)
+                            optionalMethodFamilies.add(family);
+                        for (const target of family ?? [symbol]) {
+                            const parameterShape = signatureBySymbol.get(target)?.params[i];
+                            if (!parameterShape)
+                                continue;
+                            parameterShape.type = addUndefined(parameterShape.type);
+                            const set = optionalParams.get(target) ?? new Set();
+                            const before = set.size;
+                            set.add(i);
+                            optionalParams.set(target, set);
+                            if (set.size !== before) {
+                                changed = true;
+                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                if (parameter) {
+                                    for (const bound of boundIdentifiersOf(parameter.name)) {
+                                        const boundSymbol = symbolOf(bound);
+                                        if (boundSymbol && !optionalSymbols.has(boundSymbol)) {
+                                            optionalSymbols.add(boundSymbol);
+                                            changed = true;
+                                        }
                                     }
                                 }
                             }
@@ -8071,9 +8083,17 @@ export class Lowerer {
             literal = literal.expression;
         // Fresh literals have no previous outer identity to preserve. Build them
         // for their storage layout, just as ordinary contextual literals do.
-        if (ts.isObjectLiteralExpression(literal) || ts.isArrayLiteralExpression(literal) || expected.kind === "f64" || expected.kind === "string") {
+        if (ts.isObjectLiteralExpression(literal) || ts.isArrayLiteralExpression(literal) ||
+            isPrimitiveCollectionKey(expected, expected.kind === "union" ? this.unions.get(expected.unionId)?.arms : undefined)) {
             return this.lowerExprExpecting(node, expected);
         }
+        const value = this.lowerExpr(node);
+        const valueArms = value.type.kind === "union" ? this.unions.get(value.type.unionId)?.arms ?? [] : [value.type];
+        // Primitive checks and reboxing preserve values, including tag-only
+        // null/undefined keys. Identity restrictions apply only to references.
+        if (valueArms.length > 0 && valueArms.every((arm) => isPrimitiveCollectionKey(arm))) {
+            return this.coerceInto(node, value, expected);
+        }
         // Assertions can perform their own conversion before slot coercion.
         // Inspect the assertion chain so a width copy cannot hide behind its
         // already-converted result type. Union-arm checks only unwrap a box.
@@ -8088,7 +8108,6 @@ export class Lowerer {
             }
             asserted = asserted.expression;
         }
-        const value = this.lowerExpr(node);
         const source = (value.type.kind === "union" ? this.unions.get(value.type.unionId)?.arms ?? [] : [value.type]).filter((type) => !isUnitType(type));
         const target = expected.kind === "union" ? this.unions.get(expected.unionId)?.arms ?? [] : [expected];
         const preservesIdentity = source.length > 0 && source.every((from) => target.some((to) => typeEquals(from, to) || (from.kind === "object" && to.kind === "object" && this.isSubclassOf(from.className, to.className))));
@@ -8749,9 +8768,10 @@ export class Lowerer {
     lowerStaticFieldInits(info) {
         return lowerStaticFieldInits(this, info);
     }
-    /** The method-like members (methods and accessors) of a class that have
-     * lowerable bodies, with their collected method-map names. */
-    *classMethodMembers(info) {
+    /** Method-like members with their collected method-map names. Body
+     * lowering omits abstract declarations; ABI analysis must include them
+     * because an abstract-typed call selects the same virtual slot. */
+    *classMethodMembers(info, includeAbstract = false) {
         if (!info.decl)
             return; // builtin error classes: runtime-provided bodies
         for (const member of info.decl.members) {
@@ -8775,7 +8795,8 @@ export class Lowerer {
             if (baseName === null)
                 continue;
             const mName = ts.isMethodDeclaration(fnLike) ? baseName : `${ts.isGetAccessor(fnLike) ? "get" : "set"}:${baseName}`;
-            if (!info.methods.get(mName) || !fnLike.body)
+            const signature = info.methods.get(mName);
+            if (!signature || (!fnLike.body && !(includeAbstract && signature.abstract)))
                 continue;
             yield { mName, member: fnLike };
         }
@@ -9946,6 +9967,9 @@ export class Lowerer {
         // methods and properties keep their existing process lowerings.
         if (stdlibGlobalNameOf(this, expr) === "process")
             return null;
+        const imported = ts.isIdentifier(expr) ? this.builtinImportOf(expr) : null;
+        if (imported?.module === "util" && imported.member === "types")
+            return "util/types";
         const stored = ts.isIdentifier(expr)
             ? (this.peekLocal(expr)?.type ?? this.globalOf(expr)?.type)
             : undefined;
@@ -10231,6 +10255,12 @@ export class Lowerer {
      * deliberately narrower than table membership because many table rows
      * are only dispatch sentinels for call-site-specific lowering. */
     lowerBuiltinCallableValue(bi, loc) {
+        if (bi.module === "util" && bi.member === "types")
+            return utilTypesModuleValue(this, loc);
+        if (bi.module === "util/types" && builtinModuleFnOf(this, bi.module, bi.member))
+            return lowerUtilTypeValue(this, bi.member, loc);
+        if (bi.module === "util" && bi.member === "getSystemErrorMap")
+            return lowerSystemErrorMapValue(this, loc);
         if (bi.module === "fs" && builtinModuleFnOf(this, bi.module, bi.member)?.fn === "fs.callbackCall") {
             return { kind: "libCall", fn: "fs.callbackValue", args: [{ kind: "strLit", value: bi.member, type: STRING, loc }], type: DYN, loc };
         }
@@ -10245,6 +10275,8 @@ export class Lowerer {
             if (param.mode === "rest")
                 return { mode: "rest", type: arrayOf(param.type) };
             if (param.mode === "optional") {
+                if (param.type.kind === "dyn" && param.defaultValue === undefined)
+                    return { mode: "omittable", type: DYN };
                 return { mode: "omittable", type: this.withUndefinedArm(param.type), bodyType: param.type };
             }
             return { mode: "required", type: param.type };
@@ -10276,7 +10308,10 @@ export class Lowerer {
                 };
                 if (valueParam.mode !== "optional")
                     return ref;
-                if ((valueParam.type.kind !== "string" && valueParam.type.kind !== "f64") || param.type.kind !== "union") {
+                // Checked runtime APIs consume undefined directly for omitted options.
+                if (valueParam.type.kind === "dyn" && valueParam.defaultValue === undefined)
+                    return ref;
+                if (valueParam.defaultValue === undefined || (valueParam.type.kind !== "string" && valueParam.type.kind !== "f64") || param.type.kind !== "union") {
                     throw new InternalCompilerError(`builtin callable value '${display}' has an unsupported optional default`);
                 }
                 const undefTag = this.armTag(param.type.unionId, UNDEFINED_T);