Sync WIP generator structures to main (#1762)

lahma · web-flow · commit 62ab48186c0f · 2024-01-27T10:32:58.000+02:00
diff --git a/Jint.Tests/Runtime/AsyncTests.cs b/Jint.Tests/Runtime/AsyncTests.cs
@@ -148,4 +148,36 @@ public void ShouldValueTaskAwaitCurrentStack()
         Assert.Equal("12", log);
     }
 #endif
+
+    [Fact(Skip = "TODO es6-await https://github.com/sebastienros/jint/issues/1385")]
+    public void ShouldHaveCorrectOrder()
+    {
+        var engine = new Engine();
+        engine.Evaluate("var log = [];");
+
+        const string Script = """
+          async function foo(name) {
+            log.push(name + " start");
+            await log.push(name + " middle");
+            log.push(name + " end");
+          }
+
+          foo("First");
+          foo("Second");
+        """;
+
+        engine.Execute(Script);
+
+        var log = engine.GetValue("log").AsArray();
+        string[] expected = [
+            "First start",
+            "First middle",
+            "Second start",
+            "Second middle",
+            "First end",
+            "Second end",
+        ];
+
+        Assert.Equal(expected, log.Select(x => x.AsString()).ToArray());
+    }
 }
diff --git a/Jint/Native/Function/Function.cs b/Jint/Native/Function/Function.cs
@@ -332,6 +332,7 @@ internal ExecutionContext PrepareForOrdinaryCall(JsValue newTarget)
                 variableEnvironment: localEnv,
                 _privateEnvironment,
                 calleeRealm,
+                generator: null,
                 function: this);
 
             // If callerContext is not already suspended, suspend callerContext.
diff --git a/Jint/Native/Function/FunctionConstructor.cs b/Jint/Native/Function/FunctionConstructor.cs
@@ -114,8 +114,24 @@ private ScriptFunction InstantiateGeneratorFunctionObject(
             Environment scope,
             PrivateEnvironment? privateScope)
         {
-            // TODO generators
-            return InstantiateOrdinaryFunctionObject(functionDeclaration, scope, privateScope);
+            var thisMode = functionDeclaration.Strict || _engine._isStrict
+                ? FunctionThisMode.Strict
+                : FunctionThisMode.Global;
+
+            var name = functionDeclaration.Function.Id?.Name ?? "default";
+            var F = OrdinaryFunctionCreate(
+                _realm.Intrinsics.GeneratorFunction.PrototypeObject,
+                functionDeclaration,
+                thisMode,
+                scope,
+                privateScope);
+
+            F.SetFunctionName(name);
+
+            var prototype = OrdinaryObjectCreate(_engine, _realm.Intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
+            F.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(prototype, PropertyFlag.Writable));
+
+            return F;
         }
     }
 }
diff --git a/Jint/Native/Function/FunctionInstance.Dynamic.cs b/Jint/Native/Function/FunctionInstance.Dynamic.cs
@@ -2,6 +2,7 @@
 using Esprima.Ast;
 using Jint.Native.Object;
 using Jint.Runtime;
+using Jint.Runtime.Descriptors;
 using Jint.Runtime.Environments;
 using Jint.Runtime.Interpreter;
 using Environment = Jint.Runtime.Environments.Environment;
@@ -45,6 +46,8 @@ internal Function CreateDynamicFunction(
                 fallbackProto = static intrinsics => intrinsics.AsyncFunction.PrototypeObject;
                 break;
             case FunctionKind.Generator:
+                fallbackProto = static intrinsics => intrinsics.GeneratorFunction.PrototypeObject;
+                break;
             case FunctionKind.AsyncGenerator:
             default:
                 ExceptionHelper.ThrowArgumentOutOfRangeException(nameof(kind), kind.ToString());
@@ -164,7 +167,8 @@ internal Function CreateDynamicFunction(
 
         if (kind == FunctionKind.Generator)
         {
-            ExceptionHelper.ThrowNotImplementedException("generators not implemented");
+            var prototype = OrdinaryObjectCreate(_engine, _realm.Intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
+            F.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(prototype, PropertyFlag.Writable));
         }
         else if (kind == FunctionKind.AsyncGenerator)
         {
diff --git a/Jint/Native/Generator/GeneratorKind.cs b/Jint/Native/Generator/GeneratorKind.cs
@@ -1,9 +1,8 @@
-namespace Jint.Native.Generator
+namespace Jint.Native.Generator;
+
+internal enum GeneratorKind
 {
-    internal enum GeneratorKind
-    {
-        NonGenerator,
-        Sync,
-        Async
-    }
-}
+    NonGenerator,
+    Sync,
+    Async
+}
diff --git a/Jint/Native/Global/GlobalObject.Properties.cs b/Jint/Native/Global/GlobalObject.Properties.cs
@@ -23,6 +23,7 @@ public partial class GlobalObject
     private static readonly Key propertyFloat32Array = "Float32Array";
     private static readonly Key propertyFloat64Array = "Float64Array";
     private static readonly Key propertyFunction = "Function";
+    private static readonly Key propertyGeneratorFunction = "Generator";
     private static readonly Key propertyInt16Array = "Int16Array";
     private static readonly Key propertyInt32Array = "Int32Array";
     private static readonly Key propertyInt8Array = "Int8Array";
@@ -97,6 +98,7 @@ protected override void Initialize()
         properties.AddDangerous(propertyFloat32Array, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.Float32Array, PropertyFlags));
         properties.AddDangerous(propertyFloat64Array, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.Float64Array, PropertyFlags));
         properties.AddDangerous(propertyFunction, new PropertyDescriptor(_realm.Intrinsics.Function, PropertyFlags));
+        properties.AddDangerous(propertyGeneratorFunction, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.GeneratorFunction, PropertyFlags));
         properties.AddDangerous(propertyInt16Array, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.Int16Array, PropertyFlags));
         properties.AddDangerous(propertyInt32Array, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.Int32Array, PropertyFlags));
         properties.AddDangerous(propertyInt8Array, new LazyPropertyDescriptor(this, static state => ((GlobalObject) state!)._realm.Intrinsics.Int8Array, PropertyFlags));
diff --git a/Jint/Native/Iterator/IteratorInstance.cs b/Jint/Native/Iterator/IteratorInstance.cs
@@ -1,4 +1,5 @@
 using System.Globalization;
+using Jint.Native.Generator;
 using Jint.Native.Object;
 using Jint.Native.RegExp;
 using Jint.Runtime;
@@ -68,7 +69,7 @@ private ObjectInstance IteratorNext()
                 var instance = jsValue as ObjectInstance;
                 if (instance is null)
                 {
-                    ExceptionHelper.ThrowTypeError(_target.Engine.Realm, "Iterator result " + jsValue + " is not an object");
+                    ExceptionHelper.ThrowTypeError(_target.Engine.Realm, $"Iterator result {jsValue} is not an object");
                 }
 
                 return instance;
@@ -210,5 +211,22 @@ public override bool TryIteratorStep(out ObjectInstance nextItem)
                 return false;
             }
         }
+
+        internal sealed class GeneratorIterator : IteratorInstance
+        {
+            private readonly GeneratorInstance _generator;
+
+            public GeneratorIterator(Engine engine, GeneratorInstance generator) : base(engine)
+            {
+                _generator = generator;
+            }
+
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
+            {
+                nextItem = IteratorResult.CreateValueIteratorPosition(_engine, done: JsBoolean.True);
+                return false;
+            }
+        }
+
     }
 }
diff --git a/Jint/Runtime/Interpreter/EvaluationContext.cs b/Jint/Runtime/Interpreter/EvaluationContext.cs
@@ -10,10 +10,9 @@ internal sealed class EvaluationContext
 {
     private readonly bool _shouldRunBeforeExecuteStatementChecks;
 
-    public EvaluationContext(Engine engine, in Completion? resumedCompletion = null)
+    public EvaluationContext(Engine engine)
     {
         Engine = engine;
-        ResumedCompletion = resumedCompletion ?? default; // TODO later
         OperatorOverloadingAllowed = engine.Options.Interop.AllowOperatorOverloading;
         _shouldRunBeforeExecuteStatementChecks = engine._constraints.Length > 0 || engine._isDebugMode;
     }
@@ -22,13 +21,11 @@ public EvaluationContext(Engine engine, in Completion? resumedCompletion = null)
     public EvaluationContext()
     {
         Engine = null!;
-        ResumedCompletion = default; // TODO later
         OperatorOverloadingAllowed = false;
         _shouldRunBeforeExecuteStatementChecks = false;
     }
 
     public readonly Engine Engine;
-    public readonly Completion ResumedCompletion;
     public bool DebugMode => Engine._isDebugMode;
 
     public SyntaxElement LastSyntaxElement
diff --git a/Jint/Runtime/Interpreter/Expressions/JintFunctionExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintFunctionExpression.cs
@@ -1,6 +1,8 @@
 using Esprima.Ast;
 using Jint.Native;
 using Jint.Native.Function;
+using Jint.Native.Object;
+using Jint.Runtime.Descriptors;
 using Jint.Runtime.Environments;
 
 namespace Jint.Runtime.Interpreter.Expressions
@@ -123,8 +125,43 @@ private ScriptFunction InstantiateAsyncFunctionExpression(EvaluationContext cont
         /// </summary>
         private ScriptFunction InstantiateGeneratorFunctionExpression(EvaluationContext context, string? name)
         {
-            // TODO generators
-            return InstantiateOrdinaryFunctionExpression(context, name);
+            var engine = context.Engine;
+            var runningExecutionContext = engine.ExecutionContext;
+            var scope = runningExecutionContext.LexicalEnvironment;
+
+            DeclarativeEnvironment? funcEnv = null;
+            if (!string.IsNullOrWhiteSpace(name))
+            {
+                funcEnv = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment);
+                funcEnv.CreateImmutableBinding(name!, strict: false);
+            }
+
+            var privateScope = runningExecutionContext.PrivateEnvironment;
+
+            var thisMode = _function.Strict || engine._isStrict
+                ? FunctionThisMode.Strict
+                : FunctionThisMode.Global;
+
+            var intrinsics = engine.Realm.Intrinsics;
+            var closure = intrinsics.Function.OrdinaryFunctionCreate(
+                intrinsics.GeneratorFunction.PrototypeObject,
+                _function,
+                thisMode,
+                funcEnv ?? scope,
+                privateScope
+            );
+
+            if (name is not null)
+            {
+                closure.SetFunctionName(name);
+            }
+
+            var prototype = ObjectInstance.OrdinaryObjectCreate(engine, intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
+            closure.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(prototype, PropertyFlag.Writable));
+
+            funcEnv?.InitializeBinding(name!, closure);
+
+            return closure;
         }
     }
 }
diff --git a/Jint/Runtime/Interpreter/JintFunctionDefinition.cs b/Jint/Runtime/Interpreter/JintFunctionDefinition.cs
@@ -2,6 +2,7 @@
 using Esprima.Ast;
 using Jint.Native;
 using Jint.Native.Function;
+using Jint.Native.Generator;
 using Jint.Native.Promise;
 using Jint.Runtime.Environments;
 using Jint.Runtime.Interpreter.Expressions;
@@ -63,11 +64,7 @@ internal Completion EvaluateBody(EvaluationContext context, Function functionObj
         }
         else if (Function.Generator)
         {
-            // TODO generators
-            // result = EvaluateGeneratorBody(functionObject, argumentsList);
-            argumentsInstance = context.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
-            _bodyStatementList ??= new JintStatementList(Function);
-            result = _bodyStatementList.Execute(context);
+            result = EvaluateGeneratorBody(context, functionObject, argumentsList);
         }
         else
         {
@@ -108,7 +105,11 @@ private static void AsyncFunctionStart(EvaluationContext context, PromiseCapabil
     /// <summary>
     /// https://tc39.es/ecma262/#sec-asyncblockstart
     /// </summary>
-    private static void AsyncBlockStart(EvaluationContext context, PromiseCapability promiseCapability, Func<EvaluationContext, Completion> asyncBody, in ExecutionContext asyncContext)
+    private static void AsyncBlockStart(
+        EvaluationContext context,
+        PromiseCapability promiseCapability,
+        Func<EvaluationContext, Completion> asyncBody,
+        in ExecutionContext asyncContext)
     {
         var runningContext = context.Engine.ExecutionContext;
         // Set the code evaluation state of asyncContext such that when evaluation is resumed for that execution contxt the following steps will be performed:
@@ -149,10 +150,23 @@ 8. Return unused.
     /// <summary>
     /// https://tc39.es/ecma262/#sec-runtime-semantics-evaluategeneratorbody
     /// </summary>
-    private static Completion EvaluateGeneratorBody(Function functionObject, JsValue[] argumentsList)
+    private Completion EvaluateGeneratorBody(
+        EvaluationContext context,
+        Function functionObject,
+        JsValue[] argumentsList)
     {
-        ExceptionHelper.ThrowNotImplementedException("generators not implemented");
-        return default;
+        var engine = context.Engine;
+        engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
+        var G = engine.Realm.Intrinsics.Function.OrdinaryCreateFromConstructor(
+            functionObject,
+            static intrinsics => intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject,
+            static (Engine engine , Realm _, object? _) => new GeneratorInstance(engine));
+
+        _bodyStatementList ??= new JintStatementList(Function);
+        _bodyStatementList.Reset();
+        G.GeneratorStart(_bodyStatementList);
+
+        return new Completion(CompletionType.Return, G, Function.Body);
     }
 
     internal State Initialize()
diff --git a/Jint/Runtime/Interpreter/JintStatementList.cs b/Jint/Runtime/Interpreter/JintStatementList.cs
diff --git a/Jint/Runtime/Interpreter/Statements/JintForInForOfStatement.cs b/Jint/Runtime/Interpreter/Statements/JintForInForOfStatement.cs

Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,9 @@ internal sealed class EvaluationContext`
`10`	`10`	`{`
`11`	`11`	`private readonly bool _shouldRunBeforeExecuteStatementChecks;`
`12`	`12`
`13`		`- public EvaluationContext(Engine engine, in Completion? resumedCompletion = null)`
	`13`	`+ public EvaluationContext(Engine engine)`
`14`	`14`	`{`
`15`	`15`	`Engine = engine;`
`16`		`- ResumedCompletion = resumedCompletion ?? default; // TODO later`
`17`	`16`	`OperatorOverloadingAllowed = engine.Options.Interop.AllowOperatorOverloading;`
`18`	`17`	`_shouldRunBeforeExecuteStatementChecks = engine._constraints.Length > 0 \|\| engine._isDebugMode;`
`19`	`18`	`}`
`@@ -22,13 +21,11 @@ public EvaluationContext(Engine engine, in Completion? resumedCompletion = null)`
`22`	`21`	`public EvaluationContext()`
`23`	`22`	`{`
`24`	`23`	`Engine = null!;`
`25`		`- ResumedCompletion = default; // TODO later`
`26`	`24`	`OperatorOverloadingAllowed = false;`
`27`	`25`	`_shouldRunBeforeExecuteStatementChecks = false;`
`28`	`26`	`}`
`29`	`27`
`30`	`28`	`public readonly Engine Engine;`
`31`		`- public readonly Completion ResumedCompletion;`
`32`	`29`	`public bool DebugMode => Engine._isDebugMode;`
`33`	`30`
`34`	`31`	`public SyntaxElement LastSyntaxElement`