...

Author: rogeralsing

src/Asynkron.JsEngine/Ast/ExpressionNodeExtensions.cs

@@ -508,11 +508,8 @@ private string DescribeMemberName()
 
         // Return a basic import.meta object with a url property
         var metaObject = new JsObject();
-        if (context.RealmState?.ObjectPrototype is not null)
-        {
-            metaObject.SetPrototype(context.RealmState.ObjectPrototype);
-        }
-
+        metaObject.RealmState = context.RealmState;
+        metaObject.SetPrototype(null);
         // Set a default URL if we can determine it from the environment
         metaObject.SetProperty("url", string.Empty);
         return metaObject;

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

@@ -2,6 +2,7 @@
 using Asynkron.JsEngine;
 using Asynkron.JsEngine.JsTypes;
 using Asynkron.JsEngine.Runtime;
+using Asynkron.JsEngine.StdLib;
 
 namespace Asynkron.JsEngine.Ast;
 
@@ -289,6 +290,8 @@ public override string ToString()
 
         private void EnsureAsyncGeneratorIntrinsics()
         {
+            var engine = _realmState.Engine ?? throw new InvalidOperationException("Engine reference is missing.");
+
             // %AsyncIteratorPrototype% (inherits from %Object.prototype%)
             if (_realmState.AsyncIteratorPrototype is null)
             {
@@ -328,13 +331,15 @@ private void EnsureAsyncGeneratorIntrinsics()
                         HasConfigurable = true
                     });
 
-                // Minimal AsyncGeneratorFunction constructor so constructor.prototype.prototype matches spec shape
                 if (_realmState.AsyncGeneratorFunctionConstructor is null)
                 {
-                    var constructor = new HostFunction(_ => null);
-                    constructor.Properties.SetPrototype(_realmState.FunctionPrototype);
-                    constructor.SetProperty("prototype", asyncGenFuncProto);
-                    _realmState.AsyncGeneratorFunctionConstructor = constructor;
+                    _realmState.AsyncGeneratorFunctionConstructor =
+                        CreateAsyncGeneratorFunctionConstructor(engine, _realmState);
+                }
+
+                if (_realmState.AsyncGeneratorFunctionConstructor is { } asyncGenCtor)
+                {
+                    asyncGenCtor.SetProperty("prototype", asyncGenFuncProto);
                 }
 
                 asyncGenFuncProto.DefineProperty("constructor",
@@ -354,6 +359,124 @@ private void EnsureAsyncGeneratorIntrinsics()
             }
         }
 
+        private static HostFunction CreateAsyncGeneratorFunctionConstructor(JsEngine engine, RealmState realm)
+        {
+            HostFunction constructor = null!;
+
+            constructor = new HostFunction((_, args) =>
+                    AsyncGeneratorFunctionConstructorBody(args, constructor, engine, realm))
+            {
+                RealmState = realm
+            };
+
+            constructor.SetInvokeWithContext((args, _, _, newTarget) =>
+                AsyncGeneratorFunctionConstructorBody(args, newTarget as IJsCallable ?? constructor, engine, realm));
+
+            StandardLibrary.DefineConstantProperty(constructor, "length", 1d, configurable: true);
+            StandardLibrary.DefineConstantProperty(constructor, "name", "AsyncGeneratorFunction", configurable: true);
+
+            if (realm.FunctionPrototype is { } functionPrototype)
+            {
+                constructor.Properties.SetPrototype(functionPrototype);
+            }
+
+            return constructor;
+        }
+
+        private static object? AsyncGeneratorFunctionConstructorBody(
+            IReadOnlyList<object?> args,
+            IJsCallable newTarget,
+            JsEngine engine,
+            RealmState realm)
+        {
+            var evalContext = realm.CreateContext();
+            var argCount = args.Count;
+            var bodyValue = argCount > 0 ? args[argCount - 1] : string.Empty;
+            var parameterCount = Math.Max(argCount - 1, 0);
+
+            var parameters = new string[parameterCount];
+            for (var i = 0; i < parameterCount; i++)
+            {
+                var paramText = ToFunctionArgumentString(args[i], evalContext, realm);
+                parameters[i] = paramText;
+            }
+
+            var bodySource = ToFunctionArgumentString(bodyValue, evalContext, realm);
+            var paramList = string.Join(",", parameters);
+            var functionSource = $"(async function* anonymous({paramList}\n) {{\n{bodySource}\n}})";
+
+            var scriptGoalOptions = new JsEngineOptions
+            {
+                AllowImportMeta = false
+            };
+
+            ParsedProgram program;
+            try
+            {
+                program = engine.ParseForExecution(functionSource, options: scriptGoalOptions);
+            }
+            catch (Parser.ParseException parseException)
+            {
+                var message = parseException.Message ?? "SyntaxError";
+                throw new ThrowSignal(StandardLibrary.CreateSyntaxError(message, evalContext, realm));
+            }
+
+            var created = engine.ExecuteProgram(
+                program,
+                engine.GlobalEnvironment,
+                CancellationToken.None);
+
+            if (created is IJsObjectLike objectLike)
+            {
+                var proto = StandardLibrary.ResolveConstructPrototype(
+                    newTarget,
+                    realm.AsyncGeneratorFunctionConstructor,
+                    realm);
+                if (proto is not null)
+                {
+                    objectLike.SetPrototype(proto);
+                }
+            }
+
+            return created;
+        }
+
+        private static string ToFunctionArgumentString(object? value, EvaluationContext evalContext, RealmState realm)
+        {
+            var primitive = Runtime.JsOps.ToPrimitive(value, "string", evalContext);
+            if (evalContext.IsThrow)
+            {
+                throw new ThrowSignal(evalContext.FlowValue);
+            }
+
+            switch (primitive)
+            {
+                case null:
+                    return "null";
+                case Symbol sym when ReferenceEquals(sym, Symbol.Undefined):
+                    return "undefined";
+                case Symbol:
+                case TypedAstSymbol:
+                    throw StandardLibrary.ThrowTypeError("Cannot convert a Symbol value to a string", evalContext, realm);
+                case bool flag:
+                    return flag ? "true" : "false";
+                case string s:
+                    return s;
+                case JsBigInt bigInt:
+                    return bigInt.Value.ToString(System.Globalization.CultureInfo.InvariantCulture);
+                case double d when double.IsNaN(d):
+                    return "NaN";
+                case double d when double.IsPositiveInfinity(d):
+                    return "Infinity";
+                case double d when double.IsNegativeInfinity(d):
+                    return "-Infinity";
+                case double d:
+                    return d.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            }
+
+            return Convert.ToString(primitive, System.Globalization.CultureInfo.InvariantCulture) ?? string.Empty;
+        }
+
         private void InitializeProperties()
         {
             EnsureAsyncGeneratorIntrinsics();

src/Asynkron.JsEngine/EvalHostFunction.cs

@@ -79,6 +79,14 @@ public EvalHostFunction(JsEngine engine)
                 environment.RealmState);
         }
 
+        if (JsEngine.ProgramContainsImportMeta(program.Typed))
+        {
+            throw StandardLibrary.ThrowSyntaxError(
+                "'import.meta' is only valid in module code.",
+                CallingContext,
+                environment.RealmState);
+        }
+
         var insideClassFieldInitializer = InClassFieldInitializer ||
                                           CallingContext?.InClassFieldInitializer == true ||
                                           (CallingJsEnvironment?.HasBinding(FieldInitializerEvalFlag) ?? false);