@scriptc/compiler 0.3.4 → 0.3.6

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

@@ -48,7 +48,7 @@ import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructu
 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";
@@ -246,10 +246,46 @@ function cleanupCall(lowerer, node, value, awaited) {
     }
     return null;
 }
-function cleanupForValue(lowerer, node, value, awaited) {
+/** The statements that dispose `value` at scope exit. `setup` receives
+ * the statements that run at the declaration, after the value is bound. */
+function cleanupForValue(lowerer, node, value, awaited, setup) {
     const loc = locOf(node);
     if (isUnitType(value.type))
         return [];
+    if (value.type.kind === "dyn") {
+        // A dyn value (an object literal, a Disposable-typed result): the
+        // declaration reads and checks its dispose method, and scope exit
+        // calls it with the value as `this`.
+        const method = lowerer.declareHiddenLocal("%dispose", DYN);
+        setup.push({
+            kind: "varDecl",
+            localId: method.id,
+            init: {
+                kind: "libCall",
+                fn: "dyn.usingMethod",
+                args: [value, { kind: "boolLit", value: awaited, type: BOOL, loc }],
+                type: DYN,
+                loc,
+            },
+            loc,
+        });
+        const call = {
+            kind: "libCall",
+            fn: "dyn.usingDispose",
+            args: [{ kind: "varRef", localId: method.id, type: DYN, loc }, value],
+            type: DYN,
+            loc,
+        };
+        return [
+            {
+                kind: "exprStmt",
+                expr: awaited
+                    ? { kind: "libCall", fn: "async.awaitDyn", args: [call], type: DYN, loc }
+                    : call,
+                loc,
+            },
+        ];
+    }
     if (value.type.kind === "union") {
         const def = lowerer.unions.get(value.type.unionId);
         if (!def)
@@ -267,7 +303,9 @@ function cleanupForValue(lowerer, node, value, awaited) {
                 type: arm,
                 loc,
             };
-            const body = cleanupForValue(lowerer, node, narrowed, awaited);
+            if (arm.kind === "dyn")
+                lowerer.unsupported("SC1090", node, "disposing a union with an 'unknown' arm");
+            const body = cleanupForValue(lowerer, node, narrowed, awaited, setup);
             out.push({
                 kind: "if",
                 cond: {
@@ -333,8 +371,9 @@ function lowerUsingStatement(lowerer, stmt) {
         if (!binding)
             throw new InternalCompilerError("lowerer bug: using declaration has no runtime binding");
         const value = varRef(binding.id, binding.type, locOf(decl.name));
-        const cleanup = cleanupForValue(lowerer, decl.name, value, awaited);
-        registrations.push({ acquire, cleanup, loc: locOf(decl) });
+        const setup = [];
+        const cleanup = cleanupForValue(lowerer, decl.name, value, awaited, setup);
+        registrations.push({ acquire: [acquire, ...setup], cleanup, loc: locOf(decl) });
     }
     return registrations;
 }
@@ -461,8 +500,8 @@ export function lowerStmts(lowerer, stmts) {
                     const registrations = lowerUsingStatement(lowerer, stmt);
                     const accounting = [];
                     for (const registration of registrations) {
-                        out.push(registration.acquire);
-                        accounting.push(registration.acquire, ...registration.cleanup);
+                        out.push(...registration.acquire);
+                        accounting.push(...registration.acquire, ...registration.cleanup);
                         if (registration.cleanup.length > 0) {
                             usingMarkers.push({
                                 start: out.length,
@@ -5446,6 +5485,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);
@@ -5655,11 +5704,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-
@@ -7388,8 +7433,10 @@ export function lowerForOf(lowerer, stmt) {
         if (!resourceLoop)
             return forValues(local.id, body);
         const resource = varRef(local.id, local.type, locOf(decl.name));
-        const cleanup = cleanupForValue(lowerer, decl.name, resource, isAwaitUsing(list));
+        const setup = [];
+        const cleanup = cleanupForValue(lowerer, decl.name, resource, isAwaitUsing(list), setup);
         return forValues(local.id, [
+            ...setup,
             {
                 kind: "tryCatch",
                 tryBody: body,