works

Author: rogeralsing

continue.md

@@ -28,6 +28,7 @@
 - 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.
 - Module evaluation now walks requested modules ahead of body execution, ResolveExport/export\* follow the spec (cycle-aware, ambiguous names filtered), module namespaces expose unambiguous exports only, and namespace [[Set]]/Reflect.set return false instead of throwing.
 - Object destructuring rest now walks [[OwnPropertyKeys]] with exclusions checked before GetOwnPropertyDescriptor, skips Get for non-enumerables, and uses the original object (including proxies) instead of cloning; the proxy rest destructuring get/gOPD/ownKeys-order tests are passing.
+- Async functions now resolve their completion through the global Promise constructor even when executed from nested scopes (class/field environments fall back to the root global object), so the async class element clusters involving same-line static async methods/private names are green again.
 
 ## Next Iteration Plan
 1. When resuming broader work, run a narrow Language filter outside `ArgumentsObject`/`Array_fromAsync` to find the next hot cluster (avoid full 43k sweep).

src/Asynkron.JsEngine/Ast/ImmutableArrayClassMemberExtensions.cs

@@ -2,6 +2,7 @@
 using Asynkron.JsEngine;
 using Asynkron.JsEngine.JsTypes;
 using Asynkron.JsEngine.StdLib;
+using Microsoft.Extensions.Logging;
 
 namespace Asynkron.JsEngine.Ast;
 
@@ -23,6 +24,15 @@ private void AssignClassMembers(IJsPropertyAccessor constructorAccessor,
                     return;
                 }
 
+                context.RealmState.Logger?.LogInformation(
+                    "Defining class member name='{Name}' isStatic={IsStatic} isPrivate={IsPrivate} isAsync={IsAsync} wasAsync={WasAsync} kind={Kind}",
+                    propertyName,
+                    member.IsStatic,
+                    member.IsPrivate,
+                    member.Function.IsAsync,
+                    member.Function.WasAsync,
+                    member.Kind);
+
                 var baseDisplayName = member.IsPrivate ? member.Name : propertyName;
                 var displayName = member.Kind switch
                 {

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

@@ -381,6 +381,11 @@ public bool TryDefineProperty(string name, PropertyDescriptor descriptor)
             var context = _realmState.CreateContext(pushScope: false);
             var callerRestore = _caller;
             using var callerFrame = context.PushCaller(this, out var previousCaller);
+            _realmState.Logger?.LogInformation(
+                "InvokeWithContext enter func={Function} isAsync={IsAsync} wasAsync={WasAsync}",
+                _function.Name?.Name ?? "<anonymous>",
+                IsAsyncFunction,
+                _wasAsyncFunction);
             if (!_isStrict && !IsArrowFunction)
             {
                 _caller = previousCaller;
@@ -847,7 +852,9 @@ _function.Name is { } hoistedName &&
                     throw new ThrowSignal(thrown);
                 }
 
-                if (!IsAsyncFunction)
+                // Use IsAsyncLike so CPS-transformed async functions (WasAsync=true, IsAsync=false)
+                // still wrap completion values in a promise.
+                if (!IsAsyncLike)
                 {
                     if (!context.IsReturn)
                     {
@@ -949,6 +956,12 @@ value is not JsObject &&
                     completionValue = Symbol.Undefined;
                 }
 
+                _realmState.Logger?.LogInformation(
+                    "Async completion func={Function} isAsync={IsAsync} wasAsync={WasAsync} completionType={Type}",
+                    _function.Name?.Name ?? "<anonymous>",
+                    IsAsyncFunction,
+                    _wasAsyncFunction,
+                    completionValue?.GetType().Name ?? "null");
                 return CreateResolvedPromise(completionValue, executionEnvironment);
             }
             catch (ThrowSignal signal) when (IsAsyncFunction || _wasAsyncFunction)

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.cs

@@ -422,11 +422,17 @@ promiseCtor is not IJsPropertyAccessor accessor ||
 
     private static object? CreateResolvedPromise(object? value, JsEnvironment environment)
     {
+        object? resolveCandidate = null;
         if (!environment.TryGet(Symbol.PromiseIdentifier, out var promiseCtor) ||
             promiseCtor is not IJsPropertyAccessor accessor ||
-            !accessor.TryGetProperty("resolve", out var resolveValue) ||
-            resolveValue is not IJsCallable resolveCallable)
-        {
+            !accessor.TryGetProperty("resolve", out resolveCandidate) ||
+            resolveCandidate is not IJsCallable resolveCallable)
+        {
+            environment.RealmState?.Logger?.LogInformation(
+                "CreateResolvedPromise falling back (promiseCtorType={CtorType}, hasResolve={HasResolve}, resolveCallable={ResolveCallable})",
+                promiseCtor?.GetType().Name ?? "null",
+                promiseCtor is IJsPropertyAccessor a && a.TryGetProperty("resolve", out _),
+                resolveCandidate is IJsCallable);
             return value;
         }
 

src/Asynkron.JsEngine/JsEnvironment.cs

@@ -1116,14 +1116,11 @@ public bool TryGet(Symbol name, out object? value)
             current = current.Enclosing;
         }
 
-        if (IsGlobalFunctionScope)
+        var rootGlobal = GetRootGlobalObject();
+        if (rootGlobal is not null && rootGlobal.TryGetProperty(name.Name, out var propertyValue))
         {
-            var rootGlobal = GetRootGlobalObject();
-            if (rootGlobal is not null && rootGlobal.TryGetProperty(name.Name, out var propertyValue))
-            {
-                value = propertyValue;
-                return true;
-            }
+            value = propertyValue;
+            return true;
         }
 
         value = null;