@scriptc/compiler 0.4.0 → 0.4.1

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

@@ -373,6 +373,10 @@ export declare function registerBuiltinErrorClasses(lowerer: Lowerer): void;
  * carried by the BACKEND, not by IR fields, so the fields list stays
  * empty and subclass field layout starts right after the prefix). */
 export declare function registerBuiltinEmitterClass(lowerer: Lowerer): void;
+/** `class Bus extends require("events") {}` in a CommonJS module: the
+ * events module is the EventEmitter class itself, so the base is the
+ * runtime emitter, exactly as through a `require("events")` binding. */
+export declare function builtinRequireBaseOf(lowerer: Lowerer, node: ts.Expression): ClassInfo | null;
 /** The runtime-provided node:stream classes as eagerly-registered
  * ClassInfos (the emitter story): mapType names `%Readable` et al the
  * moment a stream type appears, so the infos must exist before any

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

@@ -4,6 +4,7 @@ import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
 import { constructedFromValue, constructedValue, superIntoResultSlot, } from "./constructor-returns.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { lowerReadlineUiNew } from "./builtins/readline.js";
+import { builtinMemberRequireDecl } from "./builtins/module-bindings.js";
 import { checkedClassUnionAssertion } from "./class-assertions.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -29,13 +30,14 @@ import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
 import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
 import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
-import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, } from "../program.js";
+import { canonicalBuiltinModule, cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, requireSpecOf, } from "../program.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, newFnCtx, own } from "./lowerer.js";
 import { isAssertClassNew } from "./assert-instances.js";
+import { isCjsRequireGlobal } from "./lower-node-module.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
-import { knownBufEncoding } from "./containers/bytes.js";
+import { knownBufEncoding, lowerNodeModulesBufferConstruct } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
@@ -526,6 +528,22 @@ export function registerBuiltinEmitterClass(lowerer) {
     };
     lowerer.classes.set(RUNTIME_EMITTER_CLASS, info);
 }
+/** `class Bus extends require("events") {}` in a CommonJS module: the
+ * events module is the EventEmitter class itself, so the base is the
+ * runtime emitter, exactly as through a `require("events")` binding. */
+export function builtinRequireBaseOf(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isCallExpression(expr) || !isJsSourceFile(expr.getSourceFile()))
+        return null;
+    const spec = requireSpecOf(expr);
+    if (spec === null || canonicalBuiltinModule(spec) !== "events")
+        return null;
+    if (!isCjsRequireGlobal(lowerer, expr.expression))
+        return null;
+    return lowerer.classes.get(RUNTIME_EMITTER_CLASS) ?? null;
+}
 /** The runtime-provided node:stream classes as eagerly-registered
  * ClassInfos (the emitter story): mapType names `%Readable` et al the
  * moment a stream type appears, so the infos must exist before any
@@ -583,10 +601,15 @@ export function builtinStreamInfoOf(lowerer, symbol) {
         // member to the stdlib class symbol. The declaration itself is
         // alias plumbing (streamClassAliasDecl — both declaration walks
         // skip it).
+        // A `var`/`let` binding of the inline require member
+        // (`var Transform = require("stream").Transform`) is the same alias
+        // plumbing as builtinMemberRequireDecl's: its declaration owns no
+        // storage either way.
         const decl = symbol.valueDeclaration;
         if (decl &&
             ts.isVariableDeclaration(decl) &&
-            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 ||
+                builtinMemberRequireDecl(decl.name, decl.initializer)) &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
@@ -891,7 +914,8 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
         const decl = symbol.valueDeclaration;
         if (decl !== undefined &&
             ts.isVariableDeclaration(decl) &&
-            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 ||
+                builtinMemberRequireDecl(decl.name, decl.initializer)) &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
@@ -1491,6 +1515,11 @@ mixin) {
             // callee is NOT a mixin function keeps the computed-expression
             // fence below.
             if (t && ts.isCallExpression(t.expression) && !t.typeArguments?.nodes) {
+                const requiredBase = builtinRequireBaseOf(lowerer, t.expression);
+                if (requiredBase) {
+                    base = requiredBase;
+                    continue;
+                }
                 const mixinBase = lowerer.mixinCallClassInfoOf(t.expression);
                 if (mixinBase) {
                     base = mixinBase;
@@ -4492,8 +4521,18 @@ export function lowerStaticFieldRead(lowerer, expr) {
     }
     // `C.name` — the JS-observable class name, a compile-time constant on
     // the direct spelling (tsc rejects user statics named `name`, so the
-    // chain above can never shadow it in TypeScript sources).
+    // chain above can never shadow it in TypeScript sources). A class of an
+    // import cycle reads it from its class object instead, whose reference
+    // checks the class's initialization (checkCycleBindingAccesses).
     if (expr.name.text === "name" && info.def.jsName !== undefined) {
+        if (lowerer.classInitFlags.get(info.def.name)?.cycle === true)
+            return {
+                kind: "libCall",
+                fn: "class.name",
+                args: [classValueRef(lowerer, info, expr.expression)],
+                type: STRING,
+                loc,
+            };
         return { kind: "strLit", value: info.def.jsName, type: STRING, loc };
     }
     if (info.callableBase)
@@ -4661,7 +4700,7 @@ export function lowerClassExpressionInfo(lowerer, expr) {
             !lowerer.computedClassBases.has(lowerer.classNamer(expr))) {
             const heritage = expr.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
             if (heritage &&
-                (ts.isCallExpression(heritage) ||
+                ((ts.isCallExpression(heritage) && !builtinRequireBaseOf(lowerer, heritage)) ||
                     (ts.isIdentifier(heritage) &&
                         (lowerer.peekLocal(heritage) ?? lowerer.globalOf(heritage)) != null))) {
                 let value = lowerer.lowerExpr(heritage);
@@ -5568,14 +5607,21 @@ function thunkAsyncSlot(overridden, mName) {
     if (overridden.sig.async !== true)
         return;
     const declarer = overridden.declarer;
+    // The slot answers the body's promise: an untyped async method's `dyn`
+    // result is the promise's payload, so the slot's ABI is that promise. An
+    // async generator method's slot keeps its generator object.
+    const ret = overridden.sig.gen || overridden.sig.ret.kind === "promise"
+        ? overridden.sig.ret
+        : { kind: "promise", inner: overridden.sig.ret };
     declarer.returnAdapters ??= new Map();
     if (!declarer.returnAdapters.has(mName)) {
         declarer.returnAdapters.set(mName, {
             params: [...overridden.sig.params],
-            ret: overridden.sig.ret,
+            ret,
             async: true,
         });
     }
+    overridden.sig.ret = ret;
     delete overridden.sig.async;
 }
 function overrideReturnAbi(lowerer, declared, inherited, className, base) {
@@ -7738,6 +7784,12 @@ function isCollectionOrErrorClass(ref) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    // A dependency's deprecated `new Buffer(...)` fallback (containers/bytes.ts).
+    {
+        const buffer = lowerNodeModulesBufferConstruct(lowerer, expr);
+        if (buffer)
+            return buffer;
+    }
     // new Function(...): Node's EvalError under
     // --disallow-code-generation-from-strings (code-generation.ts).
     if (codeGenerationCalleeOf(lowerer, expr.expression) === "Function")