@scriptc/compiler 0.3.4 → 0.3.6

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

@@ -1,5 +1,6 @@
 import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
+import { lowerReadlineUiNew } from "./builtins/readline.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
@@ -7,6 +8,7 @@ import { InternalCompilerError } from "../../errors.js";
  * synthesized derived ctors and field initializers, super calls and super
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
+import { fsStreamClassOf, lowerFsStreamNew } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
 import { lowerZlibStreamNew, zlibStreamModeOf } from "./builtins/compression.js";
 import { BOOL, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
@@ -27,7 +29,7 @@ import { bufEncoding } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
-import { lowerWorkerNew } from "./builtins/workers.js";
+import { lowerMessageChannelNew, lowerWorkerNew } from "./builtins/workers.js";
 import { unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
 import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.js";
@@ -389,6 +391,10 @@ export function registerBuiltinErrorClasses(lowerer) {
                     { name: "%systemCall", type: STRING },
                     { name: "%systemPath", type: STRING },
                     { name: "%systemDest", type: STRING },
+                    { name: "%systemMessage", type: STRING },
+                    { name: "%systemCode", type: STRING },
+                    { name: "%nativePlain", type: BOOL },
+                    { name: "%errnoOrder", type: BOOL },
                 ],
                 loc,
             },
@@ -1446,6 +1452,9 @@ mixin) {
             if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%AssertionError") {
                 lowerer.unsupported("SC1090", t, "extending AssertionError (its constructor takes an options object the subclass constructor would have to forward — extend Error, or construct AssertionError directly)");
             }
+            if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%SuppressedError") {
+                lowerer.unsupported("SC1090", t, "extending SuppressedError (extend Error and keep error and suppressed in fields)");
+            }
             const named = (symbol && lowerer.classBySymbol.get(symbol)) ??
                 lowerer.builtinErrorInfoOf(symbol) ??
                 lowerer.builtinEmitterInfoOf(symbol) ??
@@ -6844,6 +6853,12 @@ export function lowerNew(lowerer, expr) {
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
+    const readlineUi = lowerReadlineUiNew(lowerer, expr);
+    if (readlineUi)
+        return readlineUi;
+    const channel = lowerMessageChannelNew(lowerer, expr);
+    if (channel)
+        return channel;
     let intlConstructor = expr.expression;
     if (ts.isIdentifier(intlConstructor)) {
         const symbol = lowerer.resolveValueSymbol(intlConstructor);
@@ -6968,6 +6983,9 @@ export function lowerNew(lowerer, expr) {
         }
         // `new stream.Readable({...})` — the namespace-member (and CJS
         // `require('stream').Readable`) construction form.
+        const fsStreamNs = fsStreamClassOf(lowerer, resolved);
+        if (fsStreamNs)
+            return lowerFsStreamNew(lowerer, expr, fsStreamNs);
         const streamInfoNs = builtinStreamInfoOf(lowerer, resolved);
         if (streamInfoNs)
             return lowerStreamNew(lowerer, expr, streamInfoNs);
@@ -7157,6 +7175,19 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        if (errInfo && errInfo.def.name === "%SuppressedError") {
+            const args = expr.arguments ?? [];
+            if (args.length > 3 || args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new SuppressedError with this argument list`, expr);
+            }
+            return {
+                kind: "libCall",
+                fn: "error.newSuppressed",
+                args: [0, 1, 2].map((index) => args[index] ? lowerer.lowerExprExpecting(args[index], DYN) : dynUndefinedExpr(loc)),
+                type: { kind: "object", className: "%SuppressedError" },
+                loc,
+            };
+        }
         if (errInfo && errInfo.def.name === "%AggregateError") {
             const args = expr.arguments ?? [];
             if (args.length > 3 || args.some(ts.isSpreadElement)) {
@@ -7199,6 +7230,9 @@ export function lowerNew(lowerer, expr) {
         }
         // `new Readable({...})` and the other stream classes: the options
         // object parses structurally in the stream spoke.
+        const fsStream = fsStreamClassOf(lowerer, symbol);
+        if (fsStream)
+            return lowerFsStreamNew(lowerer, expr, fsStream);
         const streamInfo = builtinStreamInfoOf(lowerer, symbol);
         if (streamInfo)
             return lowerStreamNew(lowerer, expr, streamInfo);
@@ -7263,6 +7297,17 @@ export function lowerNew(lowerer, expr) {
             };
             const pattern = strArg(args[0], "pattern");
             const flags = strArg(args[1], "flags argument");
+            // Node accepts the 'd' and 'v' flags the engine does not have; a
+            // literal flags string refuses here like the literal regex form.
+            if (flags.kind === "strLit" && args[1] !== undefined) {
+                for (const f of ["d", "v"]) {
+                    if (flags.value.includes(f)) {
+                        lowerer.unsupported("SC1120", args[1], f === "d"
+                            ? "the regex 'd' flag (match indices)"
+                            : "the regex 'v' flag (unicode sets)");
+                    }
+                }
+            }
             return {
                 kind: "libCall",
                 fn: "regex.new",