@scriptc/compiler 0.3.3 → 0.3.5

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

@@ -39,14 +39,16 @@ import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js"
 import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
-import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
+import { staticAssertInstanceDecl } from "./assert-instances.js";
+import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerNetServerMaxConnectionsAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
 import { lowerUrlAssignment } from "./builtins/url.js";
 import { isFspGlobCall, lowerFspGlobForAwait } from "./builtins/fs-glob.js";
+import { isTimersPromisesIntervalCall } from "./builtins/timers.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, } from "./builtins/module-bindings.js";
 import { lowerNodeModuleCall } from "./builtins/module-resolution.js";
 import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerIncDecTarget, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompoundStatement, lowerIncDec, lowerIncDecTarget, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
 import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-exprs.js";
@@ -3458,6 +3460,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // builtinStreamInfoOf's alias following).
     if (!isLet && streamClassAliasDecl(lowerer, decl.name, decl.initializer))
         return null;
+    // `const a = new Assert(<literal options>)` used only for method calls:
+    // a static instance whose calls lower with its options (assert-instances.ts);
+    // the declaration emits nothing (collectGlobals skipped its global by the
+    // same test).
+    if (!isLet && staticAssertInstanceDecl(lowerer, decl.name, decl.initializer) !== null)
+        return null;
     // `const process = globalThis.process` — a stdlib-global snapshot:
     // alias plumbing (see stdlibGlobalAliasDecl), no storage, no code.
     const stableStdlibAlias = !isLet ||
@@ -5291,6 +5299,12 @@ export function lowerExprStatement(lowerer, expr) {
                     if (timeoutProp)
                         return timeoutProp;
                 }
+                // server.maxConnections — net.Server's connection cap.
+                {
+                    const capProp = lowerNetServerMaxConnectionsAssignment(lowerer, expr.left, expr.right, locOf(expr));
+                    if (capProp)
+                        return capProp;
+                }
                 // `N.x = v` — a namespace-qualified write: exported `let`
                 // members are module globals, so the qualified spelling assigns
                 // exactly like the bare one inside the namespace body.
@@ -5432,6 +5446,16 @@ export function lowerExprStatement(lowerer, expr) {
                         }
                     }
                 }
+                if (!expr.left.questionDotToken &&
+                    lowerer.stdlibGlobalMember(expr.left, "Buffer") === "poolSize") {
+                    const loc = locOf(expr);
+                    const value = lowerer.lowerExprExpecting(expr.right, F64);
+                    return {
+                        kind: "exprStmt",
+                        expr: { kind: "libCall", fn: "buffer.setPoolSize", args: [value], type: VOID, loc },
+                        loc,
+                    };
+                }
                 if (!expr.left.questionDotToken &&
                     lowerer.stdlibGlobalMember(expr.left, "process") === "exitCode") {
                     const loc = locOf(expr);
@@ -5641,11 +5665,7 @@ export function lowerExprStatement(lowerer, expr) {
                 if (symbolFieldInfo(lowerer, expr.left)) {
                     return lowerer.lowerFieldCompound(expr.left, compound, expr.right, locOf(expr));
                 }
-                return {
-                    kind: "exprStmt",
-                    expr: lowerElementCompound(lowerer, expr, compound),
-                    loc: locOf(expr),
-                };
+                return lowerElementCompoundStatement(lowerer, expr, compound);
             }
             if (ts.isPropertyAccessExpression(expr.left)) {
                 // `N.x += v` — the namespace-qualified spelling of a module-
@@ -6709,11 +6729,18 @@ export function lowerForOf(lowerer, stmt) {
             head = head.expression;
         if (isFspGlobCall(lowerer, head))
             return lowerFspGlobForAwait(lowerer, stmt, head);
+        if (isTimersPromisesIntervalCall(lowerer, head)) {
+            const iterable = lowerer.lowerExpr(head);
+            if (iterable.type.kind === "generator" && iterable.type.async) {
+                return lowerForAwaitGenerator(lowerer, stmt, iterable, labels);
+            }
+        }
     }
     const awaitArray = !!stmt.awaitModifier && lowerer.mapTypeOf(lowerer.typeOf(stmt.expression))?.kind === "array";
     if (stmt.awaitModifier && !awaitArray) {
         {
-            const genT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
+            const genT = lowerer.stageSourceType(stmt.expression) ??
+                lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
             if (genT?.kind === "generator" && genT.async) {
                 const iterable = lowerer.lowerExpr(stmt.expression);
                 if (iterable.type.kind === "generator" && iterable.type.async) {