@opencode/codemode 0.0.0-dev-19959 → 0.0.0-dev-19961

package/dist/interpreter/interpreter.js

@@ -6,7 +6,7 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, hostCursor, IteratorObj, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
+import { assign, Callable, define, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -318,7 +318,16 @@ class Frame {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
-        return new Fn(this.ctx.builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        const builtins = this.ctx.builtins;
+        const fn = new Fn(builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        // Each generator function gets its own prototype, so `g() instanceof g` holds as in JS.
+        if (node.generator)
+            define(fn, "prototype", new Obj(node.async ? builtins.AsyncGenerator : builtins.Generator), hidden);
+        // The body of a named function expression sees its own name, read-only.
+        if (node.type === "FunctionExpression" && node.id) {
+            fn.capturedScopes.push(new Map([[node.id.name, { mutable: false, value: fn, initialized: true }]]));
+        }
+        return fn;
     }
     // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
     evaluateNamed(node, name) {
@@ -327,11 +336,12 @@ class Frame {
         }
         return this.evaluateExpression(node);
     }
+    // Repeated `function` declarations and `var` clashes are legal: the last declaration wins.
     hoistFunctions(statements) {
         for (const node of statements) {
             if (node.type !== "FunctionDeclaration")
                 continue;
-            this.scopes.declare(node.id.name, this.createFunction(node), true, node);
+            this.scopes.current().set(node.id.name, { mutable: true, value: this.createFunction(node), initialized: true });
         }
     }
     // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
@@ -1373,13 +1383,14 @@ class Frame {
                 return yield* invocation.evaluateExpression(fn.body);
             });
             if (fn.generator)
-                return Effect.succeed(this.createGenerator(invocation, run, fn.async));
+                return Effect.succeed(this.createGenerator(invocation, run, fn));
             if (!fn.async)
                 return run;
             return this.ctx.pending.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.ctx, value, self)));
         });
     }
-    createGenerator(invocation, run, asynchronous) {
+    createGenerator(invocation, run, fn) {
+        const asynchronous = fn.async;
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
         invocation.generatorState = state;
         invocation.generatorAsync = asynchronous;
@@ -1438,8 +1449,8 @@ class Frame {
             }
             return Deferred.await(request.response);
         };
-        const generator = new GeneratorObj(asynchronous ? builtins.AsyncGenerator : builtins.Generator, asynchronous, request);
-        return generator;
+        const proto = get(fn, "prototype");
+        return new GeneratorObj(proto instanceof Obj ? proto : builtins.Generator, asynchronous, request);
     }
     completeGeneratorRequests(state, asynchronous) {
         const self = this;
@@ -1751,9 +1762,11 @@ class Frame {
     }
     evaluateDeleteExpression(argument) {
         const target = argument.type === "ChainExpression" ? argument.expression : argument;
-        if (target.type !== "MemberExpression") {
+        if (target.type === "Identifier")
             throw typeError("Only data fields may be deleted.", argument);
-        }
+        // `delete <non-reference>` evaluates the operand and is true, as in JS.
+        if (target.type !== "MemberExpression")
+            return Effect.map(this.evaluateExpression(target), () => true);
         return Effect.map(this.getMemberReference(target), (reference) => {
             if (reference === OptionalShortCircuit)
                 return true;

package/dist/interpreter/objects.d.ts

@@ -87,10 +87,10 @@ export declare abstract class Callable extends Opaque {
 export declare class Fn extends Callable {
     readonly parameters: ReadonlyArray<Pattern>;
     readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly capturedScopes: Array<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean);
 }
 export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>;
 export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>;

package/dist/stdlib/collections.js

@@ -166,7 +166,7 @@ export const mapGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Map.forEach");
                 return Effect.gen(function* () {
-                    for (const [key, item] of Array.from(target.map.entries()))
+                    for (const [key, item] of target.map.entries())
                         yield* apply([item, key, target]);
                     return undefined;
                 });
@@ -356,7 +356,7 @@ export const setGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Set.forEach");
                 return Effect.gen(function* () {
-                    for (const item of Array.from(target.set.values()))
+                    for (const item of target.set.values())
                         yield* apply([item, item, target]);
                     return undefined;
                 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19959",
+  "version": "0.0.0-dev-19961",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",