run_export

Author: alii

src/arc.gleam

@@ -378,7 +378,6 @@ fn handle_repl_line(
         entry.ReplEnv(
           global_object:,
           lexical_globals: dict.new(),
-          const_lexical_globals: set.new(),
           symbol_descriptions: dict.new(),
           symbol_registry: dict.new(),
           realms: dict.new(),
@@ -628,7 +627,6 @@ fn new_repl_state() {
     env: entry.ReplEnv(
       global_object:,
       lexical_globals: dict.new(),
-      const_lexical_globals: set.new(),
       symbol_descriptions: dict.new(),
       symbol_registry: dict.new(),
       realms: dict.new(),

src/arc/beam.gleam

@@ -304,7 +304,6 @@ fn make_spawner(
   let builtins = state.builtins
   let global_object = state.global_object
   let lexical_globals = state.lexical_globals
-  let const_lexical_globals = state.const_lexical_globals
   let symbol_descriptions = state.symbol_descriptions
   let symbol_registry = state.symbol_registry
   fn() {
@@ -326,7 +325,6 @@ fn make_spawner(
         builtins,
         global_object,
         lexical_globals,
-        const_lexical_globals,
         symbol_descriptions,
         symbol_registry,
       )

src/arc/compiler/emit.gleam

@@ -23,7 +23,7 @@ import arc/vm/opcode.{
   IrNewObject, IrNewRegExp, IrObjectRestCopy, IrObjectSpread, IrPop, IrPopTry,
   IrPrivateIn, IrPushConst, IrPushTry, IrPutElem, IrPutField, IrPutPrivateField,
   IrPutSuperProp, IrPutSuperPropComputed, IrRet, IrReturn, IrScopeGetVar,
-  IrScopePutVar, IrScopeReboxVar,
+  IrScopeInitVar, IrScopePutVar, IrScopeReboxVar,
   IrScopeTypeofVar, IrSetLine, IrSetThis, IrSetupDerivedClass, IrSwap, IrThrow,
   IrTypeOf, IrUnaryOp, IrYield, IrYieldStar,
 }
@@ -493,12 +493,13 @@ fn declare_lex(e: Emitter, name: String, is_const: Bool) -> Emitter {
 }
 
 /// Store the value on top of stack into a let/const binding declared via
-/// declare_lex. Routes to IrInitGlobalLex (bypasses TDZ/const checks) or
-/// IrScopePutVar (resolves to PutLocal).
+/// declare_lex. Routes to IrInitGlobalLex (global lexical record) or
+/// IrScopeInitVar (local slot). Both are *initialization*, so neither triggers
+/// the const-reassignment check — only IrScopePutVar (true assignment) does.
 fn init_lex(e: Emitter, name: String) -> Emitter {
   case at_global_lex(e) {
     True -> emit_ir(e, IrInitGlobalLex(name))
-    False -> emit_ir(e, IrScopePutVar(name))
+    False -> emit_ir(e, IrScopeInitVar(name))
   }
 }
 

src/arc/compiler/resolve.gleam

@@ -24,12 +24,13 @@ import arc/vm/opcode.{
   IrJumpIfTrue, IrLabel, IrMakeClosure, IrNewObject, IrNewRegExp,
   IrObjectRestCopy, IrObjectSpread, IrPop, IrPopTry, IrPrivateIn, IrPushConst,
   IrPushTry, IrPutBoxed, IrPutElem, IrPutEvalVar, IrPutField, IrPutGlobal,
-  IrPutLocal, IrPutPrivateField, IrRet, IrReturn, IrScopeGetVar, IrScopePutVar,
+  IrPutLocal, IrPutPrivateField, IrRet, IrReturn, IrScopeGetVar, IrScopeInitVar,
+  IrScopePutVar,
   IrCheckSuperThis, IrGetSuperProp, IrGetSuperProp2, IrGetSuperPropComputed,
   IrGetSuperPropComputed2, IrPutSuperProp, IrPutSuperPropComputed,
   IrScopeReboxVar, IrScopeTypeofVar, IrSetLine, IrSetThis, IrSetupDerivedClass,
-  IrSwap, IrThrow, IrTypeOf, IrTypeofEvalVar, IrTypeofGlobal, IrUnaryOp, IrYield,
-  IrYieldStar,
+  IrSwap, IrThrow, IrThrowError, IrTypeOf, IrTypeofEvalVar, IrTypeofGlobal,
+  IrUnaryOp, IrYield, IrYieldStar,
 }
 import arc/vm/value.{
   type EnvCapture, type FuncTemplate, type JsValue, FuncTemplate,
@@ -141,6 +142,7 @@ fn resolve_ops(
     // Scope-aware ops should NOT appear here (consumed by Phase 2)
     [IrScopeGetVar(_), ..]
     | [IrScopePutVar(_), ..]
+    | [IrScopeInitVar(_), ..]
     | [IrScopeTypeofVar(_), ..]
     | [IrScopeReboxVar(_), ..]
     | [IrGetThis, ..]
@@ -252,6 +254,8 @@ fn resolve_ops(
 
     // Exception handling
     [IrThrow, ..rest] -> resolve_ops(rest, labels, [opcode.Throw, ..acc])
+    [IrThrowError(kind), ..rest] ->
+      resolve_ops(rest, labels, [opcode.ThrowError(kind), ..acc])
     [IrPopTry, ..rest] -> resolve_ops(rest, labels, [opcode.PopTry, ..acc])
     [IrRet, ..rest] -> resolve_ops(rest, labels, [opcode.Ret, ..acc])
 

src/arc/compiler/scope.gleam

@@ -14,11 +14,11 @@ import arc/compiler/emit.{
   LeaveScope, LetBinding, ParamBinding, VarBinding,
 }
 import arc/vm/opcode.{
-  type IrOp, IrBoxLocal, IrDeclareEvalVar, IrDeclareGlobalVar, IrGetBoxed,
-  IrGetEvalVar, IrGetGlobal, IrGetLocal, IrGetThis, IrPushConst, IrPutBoxed,
-  IrPutEvalVar, IrPutGlobal, IrPutLocal, IrScopeGetVar, IrScopePutVar,
-  IrScopeReboxVar, IrScopeTypeofVar, IrSetThis, IrTypeOf, IrTypeofEvalVar,
-  IrTypeofGlobal,
+  type IrOp, ConstAssignment, IrBoxLocal, IrDeclareEvalVar, IrDeclareGlobalVar,
+  IrGetBoxed, IrGetEvalVar, IrGetGlobal, IrGetLocal, IrGetThis, IrPushConst,
+  IrPutBoxed, IrPutEvalVar, IrPutGlobal, IrPutLocal, IrScopeGetVar,
+  IrScopeInitVar, IrScopePutVar, IrScopeReboxVar, IrScopeTypeofVar, IrSetThis,
+  IrThrowError, IrTypeOf, IrTypeofEvalVar, IrTypeofGlobal,
 }
 import arc/vm/value.{type JsValue, JsUndefined, JsUninitialized}
 import gleam/bool
@@ -323,7 +323,27 @@ fn resolve_one(r: Resolver, op: EmitterOp) -> Resolver {
       }
     }
 
+    // Assignment (`x = …`, `x += …`, `x++`, destructuring-assign). A store to a
+    // const local binding is a runtime TypeError; the local store ops carry no
+    // const flag, so — like QuickJS's resolve_scope_var — we resolve it here and
+    // emit a throw. Initialization goes through IrScopeInitVar, never here.
     Ir(IrScopePutVar(name)) -> {
+      case lookup(r.scopes, name) {
+        Some(Binding(kind: ConstBinding, ..)) ->
+          emit(r, IrThrowError(ConstAssignment))
+        Some(Binding(index:, is_boxed: True, ..)) -> emit(r, IrPutBoxed(index))
+        Some(Binding(index:, is_boxed: False, ..)) -> emit(r, IrPutLocal(index))
+        None ->
+          case r.fallthrough {
+            ToGlobal -> emit(r, IrPutGlobal(name))
+            ToEvalEnv -> emit(r, IrPutEvalVar(name))
+          }
+      }
+    }
+
+    // Initialization of a let/const binding — same lowering as IrScopePutVar
+    // but never const-checked (binding a const for the first time is allowed).
+    Ir(IrScopeInitVar(name)) -> {
       case lookup(r.scopes, name) {
         Some(Binding(index:, is_boxed: True, ..)) -> emit(r, IrPutBoxed(index))
         Some(Binding(index:, is_boxed: False, ..)) -> emit(r, IrPutLocal(index))

src/arc/vm/exec/entry.gleam

@@ -16,7 +16,6 @@ import arc/vm/value.{type FuncTemplate, type JsValue, type Ref, JsObject}
 import gleam/dict
 import gleam/option.{type Option, None, Some}
 import gleam/result
-import gleam/set
 
 // ============================================================================
 // Public types
@@ -33,8 +32,7 @@ pub type ModuleResult {
 pub type ReplEnv {
   ReplEnv(
     global_object: Ref,
-    lexical_globals: dict.Dict(String, JsValue),
-    const_lexical_globals: set.Set(String),
+    lexical_globals: dict.Dict(String, value.LexicalGlobal),
     symbol_descriptions: dict.Dict(value.SymbolId, String),
     symbol_registry: dict.Dict(String, value.SymbolId),
     /// Realm builtins registry, keyed by RealmSlot ref.
@@ -99,7 +97,6 @@ pub fn run_module(
       builtins,
       global_object,
       dict.new(),
-      set.new(),
       dict.new(),
       dict.new(),
     )
@@ -131,7 +128,6 @@ pub fn run_and_drain_repl(
         builtins,
         env.global_object,
         env.lexical_globals,
-        env.const_lexical_globals,
         env.symbol_descriptions,
         env.symbol_registry,
       ),
@@ -145,7 +141,6 @@ pub fn run_and_drain_repl(
     ReplEnv(
       global_object: drained.global_object,
       lexical_globals: drained.lexical_globals,
-      const_lexical_globals: drained.const_lexical_globals,
       symbol_descriptions: drained.symbol_descriptions,
       symbol_registry: drained.symbol_registry,
       realms: drained.realms,
@@ -154,13 +149,15 @@ pub fn run_and_drain_repl(
 }
 
 /// Call a function value with `this` and `args`, then run the `finish` driver
-/// to drain. The counterpart to `run`/`run_with` for a value you already hold
-/// — e.g. a `receive` export read off a module namespace — so an embedder can
-/// invoke it the way the engine would, without re-evaluating a script. This is
-/// the host-call-then-drain pattern (cf. Node's MakeCallback, QuickJS
-/// `JS_Call` + the `JS_ExecutePendingJob` loop): draining happens at this
-/// outermost call only, so don't call it from inside a host function — use the
-/// re-entrant `state.call` there.
+/// to drain. The counterpart to `run`/`run_with` for a value you already hold —
+/// e.g. a `receive` export read off a module namespace — letting an embedder
+/// invoke it without re-evaluating a script. The host-call-then-drain pattern
+/// (cf. Node's MakeCallback, QuickJS `JS_Call` + `JS_ExecutePendingJob`).
+///
+/// Built on the lossless `interpreter.call_root`, so it shares its shape with
+/// `run`/`run_with`: a thrown value is a `ThrowCompletion`, an engine `VmError`
+/// surfaces as `Error` (not a panic — the embedder is outside the VM and can
+/// handle it). Draining happens once, at this outermost call.
 pub fn run_export(
   callee: JsValue,
   this_val: JsValue,
@@ -170,16 +167,10 @@ pub fn run_export(
   global_object: Ref,
   finish: fn(State) -> State,
 ) -> Result(Completion, VmError) {
-  let executed =
-    interpreter.call_to_completion(
-      callee,
-      this_val,
-      args,
-      heap,
-      builtins,
-      global_object,
-    )
-  use #(settled, drained) <- result.map(settle(executed, finish))
+  use #(settled, drained) <- result.map(settle(
+    interpreter.call_root(callee, this_val, args, heap, builtins, global_object),
+    finish,
+  ))
   completion_of(settled, drained.heap)
 }