Fix realm promise access and stabilize Array.fromAsync

Author: rogeralsing

continue.md

@@ -24,8 +24,9 @@
 - Array index assignments now walk prototype accessors/writable descriptors (including inherited setters) before falling back to element storage, so member-expression for-in targets trigger Array.prototype setters and typed array for-in over resizable buffers enumerates the expected indices.
 - `using` and `await using` declarations still TypeError on non-object initializers but now allow initializer-less for-in/of heads with per-iteration lexical environments, so the TDZ/fresh-binding for-of cases are green.
 - Typed array subclass instances now report their concrete @@toStringTag, generator/async generator functions (and their bound/proxy wrappers) are treated as non-constructors during class heritage resolution, and derived classes extending null leave `this` uninitialized until super, so the class subclass builtins/null-proto/generator superclass cases are green.
+- Super calls now bind sloppy callees through the global when the caller's `this` is uninitialized, resolve the base constructor from the current constructor `[[Prototype]]`, and defer `super` property key coercion until after capturing the super base, so the `Expressions_super` cluster is green.
+- Promise constructor is exposed on RealmState and pulled from closure or realm for async generators; `Array.fromAsync` async-path now drives iteration iteratively (no recursive promise callbacks) and the full `Array_fromAsync` filter passes. Strict `arguments-object` assignment tests now build proper JS error objects and pass.
 
 ## Next Iteration Plan
-1. Re-run the Language suite to refresh the current failure set after the for-in/of using and array setter fixes.
-2. Triage the next largest failing cluster from that run (modules/import/defer if they resurface, otherwise whatever is hottest), adding realm logging if the failure isn’t obvious.
-3. Iterate through the refreshed list in priority order, landing targeted fixes and re-running the filtered clusters as they’re addressed.
+1. When resuming broader work, run a narrow Language filter outside `ArgumentsObject`/`Array_fromAsync` to find the next hot cluster (avoid full 43k sweep).
+2. Triage any new failures/hangs with targeted filters; add realm logging only if symptoms remain opaque.

src/Asynkron.JsEngine/Ast/AssignmentReference.cs

@@ -104,6 +104,62 @@ private static AssignmentReference ResolveMember(
                     context,
                     context.RealmState);
             }
+
+            var superPropertyValue = evaluateExpression(member.Property, environment, context);
+            if (context.ShouldStopEvaluation)
+            {
+                return new AssignmentReference(() => Symbol.Undefined, _ => { });
+            }
+
+            var binding = TypedAstEvaluator.ExpectSuperBinding(environment, context);
+            string? propertyNameCache = null;
+            string GetPropertyName()
+            {
+                propertyNameCache ??= JsOps.GetRequiredPropertyName(superPropertyValue, context);
+                return propertyNameCache;
+            }
+
+            return new AssignmentReference(
+                () =>
+                {
+                    if (binding.Prototype is null)
+                    {
+                        throw StandardLibrary.ThrowTypeError(
+                            "Cannot read properties of null (reading from super)",
+                            context,
+                            context.RealmState);
+                    }
+
+                    var propertyName = GetPropertyName();
+                    return binding.TryGetProperty(propertyName, out var value)
+                        ? value
+                        : Symbol.Undefined;
+                },
+                newValue =>
+                {
+                    if (!binding.IsThisInitialized)
+                    {
+                        throw TypedAstEvaluator.CreateSuperReferenceError(environment, context, null);
+                    }
+
+                    if (binding.Prototype is null)
+                    {
+                        throw StandardLibrary.ThrowTypeError(
+                            "Cannot assign to super property when prototype is null or undefined.",
+                            context,
+                            context.RealmState);
+                    }
+
+                    var propertyName = GetPropertyName();
+                    if (!binding.TrySetProperty(propertyName, newValue, out _) &&
+                        context.CurrentScope.IsStrict)
+                    {
+                        throw StandardLibrary.ThrowTypeError(
+                            $"Cannot assign to read only property '{propertyName}' of object",
+                            context,
+                            context.RealmState);
+                    }
+                });
         }
 
         var target = evaluateExpression(member.Target, environment, context);

src/Asynkron.JsEngine/Ast/ExpressionNodeExtensions.cs

@@ -274,7 +274,8 @@ private bool ContainsDirectEvalCall()
                 // For a constructor, the active function is available via NewTarget when it's
                 // a constructor being invoked via 'new'.
                 object? dynamicSuperConstructor = binding.Constructor;
-                if (environment.TryGet(Symbol.NewTarget, out var newTarget) &&
+                if (dynamicSuperConstructor is null &&
+                    environment.TryGet(Symbol.NewTarget, out var newTarget) &&
                     newTarget is IJsObjectLike activeFunction)
                 {
                     // Get the current [[Prototype]] of the active function (constructor)

src/Asynkron.JsEngine/Ast/JsEnvironmentExtensions.cs

@@ -104,7 +104,7 @@ private void EnsureFunctionScopedVarBinding(Symbol name,
             environment.DefineFunctionScoped(name, Symbol.Undefined, false, context: context, canDelete: allowDelete);
         }
 
-        private SuperBinding ExpectSuperBinding(EvaluationContext context)
+        internal SuperBinding ExpectSuperBinding(EvaluationContext context)
         {
             var logger = environment.RealmState?.Logger;
             try
@@ -220,7 +220,7 @@ private bool TryCreateSuperBindingFromThis(
             return true;
         }
 
-        private Exception CreateSuperReferenceError(EvaluationContext context,
+        internal Exception CreateSuperReferenceError(EvaluationContext context,
             Exception? inner)
         {
             environment.RealmState?.Logger?.LogInformation("SuperBinding: reference error thisInit? {ThisInit}", context.IsThisInitialized);

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.AsyncGeneratorInstance.cs

@@ -57,8 +57,18 @@ public JsObject CreateAsyncIteratorObject()
         private object? CreateStepPromise(TypedGeneratorInstance.ResumeMode mode, object? argument)
         {
             // Look up the global Promise constructor from the closure environment.
-            if (!closure.TryGet(Symbol.PromiseIdentifier, out var promiseCtorObj) ||
-                promiseCtorObj is not IJsCallable promiseCtor)
+            IJsCallable? promiseCtor = null;
+            if (closure.TryGet(Symbol.PromiseIdentifier, out var promiseCtorObj) &&
+                promiseCtorObj is IJsCallable promiseFromEnv)
+            {
+                promiseCtor = promiseFromEnv;
+            }
+            else if (realmState.PromiseConstructor is IJsCallable promiseFromRealm)
+            {
+                promiseCtor = promiseFromRealm;
+            }
+
+            if (promiseCtor is null)
             {
                 throw new InvalidOperationException("Promise constructor is not available in the current environment.");
             }

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.TypedFunction.cs

@@ -618,7 +618,17 @@ public bool TryDefineProperty(string name, PropertyDescriptor descriptor)
                 {
                     if (thisValue is null || ReferenceEquals(thisValue, Symbol.Undefined))
                     {
-                        boundThis = CallingJsEnvironment?.Get(Symbol.This);
+                        try
+                        {
+                            boundThis = CallingJsEnvironment?.Get(Symbol.This);
+                        }
+                        catch (InvalidOperationException ex) when (ex.Message.StartsWith("ReferenceError:",
+                                     StringComparison.Ordinal))
+                        {
+                            // If the caller's `this` binding is uninitialized (e.g., derived ctor before super()),
+                            // fall back to the global object per non-strict this-binding semantics.
+                            boundThis = Symbol.Undefined;
+                        }
                         if (boundThis is null || ReferenceEquals(boundThis, Symbol.Undefined))
                         {
                             boundThis = _realmState.Engine?.GlobalObject;
@@ -694,7 +704,18 @@ public bool TryDefineProperty(string name, PropertyDescriptor descriptor)
 
                 if (_homeObject is not null || _superConstructor is not null || prototypeForSuper is not null)
                 {
-                    var binding = new SuperBinding(_superConstructor, prototypeForSuper, boundThis,
+                    var runtimeSuperConstructor = _superConstructor;
+                    if (_isClassConstructor)
+                    {
+                        var runtimeCtorPrototype =
+                            (this as IPrototypeAccessorProvider)?.PrototypeAccessor ?? Prototype;
+                        if (runtimeCtorPrototype is IJsEnvironmentAwareCallable ctorLike)
+                        {
+                            runtimeSuperConstructor = ctorLike;
+                        }
+                    }
+
+                    var binding = new SuperBinding(runtimeSuperConstructor, prototypeForSuper, boundThis,
                         initialThisInitialized);
                     functionEnvironment.RealmState?.Logger?.LogInformation(
                         "SuperBinding: define in function env env={Env} isCtor={IsCtor} isDerivedCtor={IsDerivedCtor} protoNull={ProtoNull} thisInit={ThisInit}",

src/Asynkron.JsEngine/EvalHostFunction.cs

@@ -65,23 +65,8 @@ public EvalHostFunction(JsEngine engine)
         }
         catch (ParseException parseException)
         {
-            var message = parseException.Message;
-            object? errorObject = message;
-            if (!environment.TryGet(Symbol.SyntaxErrorIdentifier, out var ctor) ||
-                ctor is not IJsCallable callable)
-            {
-                throw new ThrowSignal(errorObject);
-            }
-
-            try
-            {
-                errorObject = callable.Invoke([message], null);
-            }
-            catch (ThrowSignal signal)
-            {
-                errorObject = signal.ThrownValue;
-            }
-
+            var errorObject =
+                StandardLibrary.CreateSyntaxError(parseException.Message, CallingContext, environment.RealmState);
             throw new ThrowSignal(errorObject);
         }
 

src/Asynkron.JsEngine/JsEngine.cs

@@ -188,7 +188,9 @@ public JsEngine(IJsEngineOptions? options = null)
         SetGlobal("AggregateError", StandardLibrary.CreateErrorConstructor(RealmState, "AggregateError"));
 
         // Register Promise constructor
-        SetGlobal("Promise", StandardLibrary.CreatePromiseConstructor(this));
+        var promiseConstructor = StandardLibrary.CreatePromiseConstructor(this);
+        SetGlobal("Promise", promiseConstructor);
+        RealmState.PromiseConstructor = promiseConstructor as IJsCallable;
 
         // Register Symbol constructor
         SetGlobal("Symbol", StandardLibrary.CreateSymbolConstructor(RealmState));

src/Asynkron.JsEngine/Runtime/RealmState.cs

@@ -51,6 +51,7 @@ public sealed class RealmState
     public HostFunction? GeneratorFunctionConstructor { get; set; }
     public JsObject? AsyncGeneratorFunctionPrototype { get; set; }
     public JsObject? AsyncGeneratorPrototype { get; set; }
+    public IJsCallable? PromiseConstructor { get; set; }
 
     // Internal flags to avoid re-attaching built-in surfaces per instance
     public bool StringPrototypeMethodsInitialized { get; set; }