@scriptc/compiler 0.3.3 → 0.3.5

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

@@ -122,6 +122,9 @@ export interface ClassInfo {
      * lifetime-regions.ts): its constructor is synthesized with the class,
      * and its methods lower at their call sites. */
     lifetimeRegion?: true;
+    /** The synthetic InternTable class (@scriptc/experimental,
+     * intern-tables.ts): synthesized like lifetimeRegion. */
+    internTable?: true;
     /** This class's own `emit` override in the FORWARDING SHAPE (the one
      * EventEmitter member a subclass may re-declare): never in `methods` —
      * emit calls keep routing through the emitter spoke, which lowers the

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

@@ -7,7 +7,9 @@ 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";
 import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
@@ -18,6 +20,7 @@ import { omittedArgFor } from "./call-arguments.js";
 import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf, } from "../program.js";
 import { PoisonError, dynFallbackType, newFnCtx, own } from "./lowerer.js";
+import { isAssertClassNew } from "./assert-instances.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
@@ -1441,6 +1444,9 @@ mixin) {
             if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%AggregateError") {
                 lowerer.unsupported("SC1090", t, "extending AggregateError (its runtime layout carries a hidden errors slot a subclass would overlap — extend Error and keep the list in a field)");
             }
+            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)");
+            }
             const named = (symbol && lowerer.classBySymbol.get(symbol)) ??
                 lowerer.builtinErrorInfoOf(symbol) ??
                 lowerer.builtinEmitterInfoOf(symbol) ??
@@ -6963,9 +6969,18 @@ 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);
+        // `new zlib.Gzip(options?)` — the zlib stream classes.
+        const zlibModeNs = zlibStreamModeOf(lowerer, resolved);
+        if (zlibModeNs !== null) {
+            const what = `new zlib.${expr.expression.name.text}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibModeNs, what, expr, loc);
+        }
         // `new N.C(...)` / `new a.Point(...)` — construction through a
         // USER namespace qualifier (import= alias chains included): the
         // member resolves to the registered program class, guarded by the
@@ -7126,6 +7141,26 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        // `new Assert(...)` that is not a static instance (assert-instances.ts):
+        // the instance would be a run-time value.
+        if (isAssertClassNew(lowerer, expr)) {
+            lowerer.noLowering("assert.Assert instances used as values", expr, "bind `new Assert(...)` with literal options to a const and only call methods on it (`const a = new Assert({ diff: 'full' }); a.strictEqual(x, y)`)");
+        }
+        if (errInfo && errInfo.def.name === "%AssertionError") {
+            // new AssertionError(options): Node validates the options object and
+            // generates the message from operator, actual and expected.
+            const args = expr.arguments ?? [];
+            if (args.length > 1 || args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new AssertionError with this argument list`, expr);
+            }
+            return {
+                kind: "libCall",
+                fn: "assert.errorNew",
+                args: [args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc)],
+                type: { kind: "object", className: "%AssertionError" },
+                loc,
+            };
+        }
         if (errInfo && errInfo.def.name === "%AggregateError") {
             const args = expr.arguments ?? [];
             if (args.length > 3 || args.some(ts.isSpreadElement)) {
@@ -7168,9 +7203,17 @@ 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);
+        const zlibMode = zlibStreamModeOf(lowerer, symbol);
+        if (zlibMode !== null) {
+            const what = `new zlib.${symbol.name}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibMode, what, expr, loc);
+        }
         // `new URL(input)`: the WHATWG URL class (stdlib/@types provenance —
         // a user's own `class URL` resolves through classBySymbol below).
         // Invalid input or base throws a catchable TypeError ("Invalid URL").