test: prove eval field super arrows stay AST-free

Author: rogeralsing

tests/Asynkron.JsEngine.Tests/AstFreeExecutionAssertionTests.cs

@@ -3146,6 +3146,51 @@ class Derived extends Base {
         }
     }
 
+    [Fact]
+    public async Task AssertNoAstEvaluation_Enabled_AllowsEvalProducedInstanceFieldArrowWithSuperExecution()
+    {
+        var originalValue = EvaluationContext.AssertNoAstEvaluation;
+
+        try
+        {
+            EvaluationContext.AssertNoAstEvaluation = true;
+
+            var program = _engine.ParseProgram("""
+                var executed = false;
+
+                class Base {
+                    constructor() {
+                        this.value = 7;
+                    }
+
+                    get read() {
+                        return this.value;
+                    }
+                }
+
+                class Derived extends Base {
+                    field = eval('executed = true; () => super.read;');
+
+                    constructor() {
+                        super();
+                    }
+                }
+
+                const instance = new Derived();
+                const arrow = instance.field;
+                `${executed}:${arrow.call({ value: 99 })}`;
+                """);
+
+            var result = await _engine.Evaluate(program);
+
+            Assert.Equal("true:7", result);
+        }
+        finally
+        {
+            EvaluationContext.AssertNoAstEvaluation = originalValue;
+        }
+    }
+
     [Fact]
     public async Task AssertNoAstEvaluation_Enabled_AllowsClassFieldInitializerCallLikeSurfaceExecution()
     {

tests/Asynkron.JsEngine.Tests/ClassElementEvalTests.cs

@@ -87,25 +87,32 @@ class Derived extends Base {
     }
 
     [Fact(Timeout = 2000)]
-    public async Task EvalProducedArrowFunctionCanUseSuper()
+    public async Task EvalProducedArrowFunctionRetainsFieldInitializerSuperBinding()
     {
         await using var engine = CreateEngine();
         var result = await engine.Evaluate("""
 
                                                        var executed = false;
                                                        class Base {
-                                                           method() {
-                                                               return 7;
+                                                           constructor() {
+                                                               this.value = 7;
+                                                           }
+
+                                                           get read() {
+                                                               return this.value;
                                                            }
                                                        }
 
                                                        class Derived extends Base {
-                                                           field = eval('executed = true; () => super.method();');
+                                                           field = eval('executed = true; () => super.read;');
+                                                           constructor() {
+                                                               super();
+                                                           }
                                                        }
 
                                                        var instance = new Derived();
                                                        var arrow = instance.field;
-                                                       executed && arrow() === 7;
+                                                       executed && arrow.call({ value: 99 }) === 7;
 
                                            """);
 

tests/Asynkron.JsEngine.Tests/JsEvaluatorTests.cs

@@ -331,35 +331,6 @@ public async Task IndexedMethodInvocationBindsThis()
         Assert.Equal(10d, result);
     }
 
-    [Fact(Skip = "Bug #363: Class field initializers with eval and super need special handling")]
-    public async Task ClassFieldInitializerCanAccessSuper()
-    {
-        await using var engine = CreateEngine();
-        var source = """
-                     var executed = false;
-                     class Base {
-                         constructor() { this.value = 1; }
-                         get read() { return this.value; }
-                     }
-                     class Derived extends Base {
-                         field = eval('executed = true; () => super.read;');
-                         constructor() {
-                             super();
-                         }
-                     }
-                     var instance = new Derived();
-                     var getter = instance.field;
-                     var result = getter.call(instance);
-                     ({ executed, result });
-                     """;
-
-        var outcome = Assert.IsType<JsObject>(await engine.Evaluate(source));
-        Assert.True(outcome.TryGetProperty("executed", out var executedValue));
-        Assert.True(JsOps.ToBoolean(executedValue));
-        Assert.True(outcome.TryGetProperty("result", out var resultValue));
-        Assert.Equal(1d, JsOps.ToNumber(resultValue));
-    }
-
     [Fact(Timeout = 2000)]
     public async Task HostFunctionReceivesThisBinding()
     {