wip-check

lahma · lahma · commit 8cc14874a9fc · 2023-10-25T18:52:28.000+03:00
diff --git a/Jint.Tests/Runtime/GeneratorTests.cs b/Jint.Tests/Runtime/GeneratorTests.cs
@@ -3,7 +3,7 @@ namespace Jint.Tests.Runtime;
 public class GeneratorTests
 {
     [Fact]
-    public void BasicYield()
+    public void LoopYield()
     {
         const string Script = @"
             const foo = function*() {
@@ -15,9 +15,185 @@ public void BasicYield()
             let str = '';
             for (const val of foo()) {
               str += val;
-            }";
+            }
+            return str;";
 
         var engine = new Engine();
         Assert.Equal("abc", engine.Evaluate(Script));
     }
+
+    [Fact]
+    public void ReturnDuringYield()
+    {
+        const string Script = @"
+            const foo = function*() {
+              yield 'a';
+              return;
+              yield 'c';
+            };
+
+            let str = '';
+            for (const val of foo()) {
+              str += val;
+            }
+            return str;";
+
+        var engine = new Engine();
+        Assert.Equal("a", engine.Evaluate(Script));
+    }
+
+    [Fact]
+    public void LoneReturnInYield()
+    {
+        const string Script = @"
+            const foo = function*() {
+              return;
+            };
+
+            let str = '';
+            for (const val of foo()) {
+              str += val;
+            }
+            return str;";
+
+        var engine = new Engine();
+        Assert.Equal("", engine.Evaluate(Script));
+    }
+
+    [Fact]
+    public void LoneReturnValueInYield()
+    {
+        const string Script = @"
+            const foo = function*() {
+              return 'a';
+            };
+
+            let str = '';
+            for (const val of foo()) {
+              str += val;
+            }
+            return str;";
+
+        var engine = new Engine();
+        Assert.Equal("", engine.Evaluate(Script));
+    }
+
+    [Fact]
+    public void YieldUndefined()
+    {
+        const string Script = @"
+            const foo = function*() {
+              yield undefined;
+            };
+
+            let str = '';
+            for (const val of foo()) {
+              str += val;
+            }
+            return str;";
+
+        var engine = new Engine();
+        Assert.Equal("undefined", engine.Evaluate(Script));
+    }
+
+    [Fact]
+    public void ReturnUndefined()
+    {
+        const string Script = @"
+            const foo = function*() {
+              return undefined;
+            };
+
+            let str = '';
+            for (const val of foo()) {
+              str += val;
+            }
+            return str;";
+
+        var engine = new Engine();
+        Assert.Equal("", engine.Evaluate(Script));
+    }
+
+    [Fact]
+    public void Basic()
+    {
+        const string Script = @"
+            function * generator(){
+              yield 5; yield 6;
+            };
+            var iterator = generator();
+            var item = iterator.next();
+            var passed = item.value === 5 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === 6 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === void undefined && item.done === true;
+            return passed;";
+
+        var engine = new Engine();
+        Assert.True(engine.Evaluate(Script).AsBoolean());
+    }
+
+    [Fact]
+    public void FunctionExpressions()
+    {
+        const string Script = @"
+            var generator = function * (){
+              yield 5; yield 6;
+            };
+            var iterator = generator();
+            var item = iterator.next();
+            var passed = item.value === 5 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === 6 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === void undefined && item.done === true;
+            return passed;";
+
+        var engine = new Engine();
+        Assert.True(engine.Evaluate(Script).AsBoolean());
+    }
+
+    [Fact]
+    public void CorrectThisBinding()
+    {
+        const string Script = @"
+            function * generator(){
+              yield this.x; yield this.y;
+            };
+            var iterator = { g: generator, x: 5, y: 6 }.g();
+            var item = iterator.next();
+            var passed = item.value === 5 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === 6 && item.done === false;
+            item = iterator.next();
+            passed &= item.value === void undefined && item.done === true;
+            return passed;";
+
+        var engine = new Engine();
+        Assert.True(engine.Evaluate(Script).AsBoolean());
+    }
+
+    [Fact]
+    public void Sending()
+    {
+        const string Script = @"
+            var sent;
+            function * generator(){
+              sent = [yield 5, yield 6];
+            };
+            var iterator = generator();
+            iterator.next();
+            iterator.next(""foo"");
+            iterator.next(""bar"");";
+
+        var engine = new Engine();
+        engine.Execute(Script);
+
+        var sent0 = engine.Evaluate("sent[0]");
+        var sent1 = engine.Evaluate("sent[1]");
+
+        Assert.Equal("foo", sent0);
+        Assert.Equal("bar", sent1);
+    }
 }
diff --git a/Jint/Native/Generator/GeneratorInstance.cs b/Jint/Native/Generator/GeneratorInstance.cs
@@ -15,6 +15,7 @@ internal sealed class GeneratorInstance : ObjectInstance
     private ExecutionContext _generatorContext;
     private readonly JsValue? _generatorBrand = null;
     private JintStatementList _generatorBody = null!;
+    public JsValue? _nextValue;
 
     public GeneratorInstance(Engine engine) : base(engine)
     {
@@ -50,6 +51,8 @@ public JsValue GeneratorResume(JsValue value, JsValue? generatorBrand)
 
         // 6. Suspend methodContext.
 
+        _nextValue = value;
+
         var context = _engine._activeEvaluationContext;
         return ResumeExecution(genContext, context!);
     }
@@ -79,9 +82,10 @@ public JsValue GeneratorResumeAbrupt(in Completion abruptCompletion, JsValue? ge
         var genContext = _generatorContext;
         var methodContext = _engine.ExecutionContext;
 
-        // Suspend methodContext.
+        // Suspend methodContext
+        _nextValue = abruptCompletion.Value;
 
-        return ResumeExecution(genContext, new EvaluationContext(_engine, abruptCompletion));
+        return ResumeExecution(genContext, new EvaluationContext(_engine));
     }
 
     private JsValue ResumeExecution(ExecutionContext genContext, EvaluationContext context)
@@ -92,19 +96,24 @@ private JsValue ResumeExecution(ExecutionContext genContext, EvaluationContext c
         var result = _generatorBody.Execute(context);
         _engine.LeaveExecutionContext();
 
+        _nextValue = null;
+
         ObjectInstance? resultValue = null;
         if (result.Type == CompletionType.Normal)
         {
             _generatorState = GeneratorState.Completed;
-            var value = context.ResumedCompletion.GetValueOrDefault();
-            resultValue = IteratorInstance.ValueIteratorPosition.Done(_engine, value);
+            resultValue =  IteratorResult.CreateValueIteratorPosition(_engine, result.Value, done: JsBoolean.True);
         }
         else if (result.Type == CompletionType.Return)
         {
-            resultValue = new IteratorInstance.ValueIteratorPosition(_engine, result.Value, false);
-            if (_generatorBody.Completed)
+            if (_generatorState == GeneratorState.SuspendedYield)
+            {
+                resultValue = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, done: JsBoolean.False);
+            }
+            else
             {
                 _generatorState = GeneratorState.Completed;
+                resultValue =  IteratorResult.CreateValueIteratorPosition(_engine, null!, done: JsBoolean.True);
             }
         }
 
diff --git a/Jint/Native/Generator/GeneratorPrototype.cs b/Jint/Native/Generator/GeneratorPrototype.cs
@@ -26,14 +26,14 @@ internal GeneratorPrototype(
 
     protected override void Initialize()
     {
-        const PropertyFlag propertyFlags = PropertyFlag.Configurable | PropertyFlag.Writable;
-        const PropertyFlag lengthFlags = PropertyFlag.Configurable;
+        const PropertyFlag PropertyFlags = PropertyFlag.Configurable | PropertyFlag.Writable;
+        const PropertyFlag LengthFlags = PropertyFlag.Configurable;
         var properties = new PropertyDictionary(4, false)
         {
             ["constructor"] = new(_constructor, PropertyFlag.Configurable),
-            ["next"] = new(new ClrFunctionInstance(Engine, "next", Next, 1, lengthFlags), propertyFlags),
-            ["return"] = new(new ClrFunctionInstance(Engine, "return", Return, 1, lengthFlags), propertyFlags),
-            ["throw"] = new(new ClrFunctionInstance(Engine, "throw", Throw, 1, lengthFlags), propertyFlags)
+            ["next"] = new(new ClrFunctionInstance(Engine, "next", Next, 1, LengthFlags), PropertyFlags),
+            ["return"] = new(new ClrFunctionInstance(Engine, "return", Return, 1, LengthFlags), PropertyFlags),
+            ["throw"] = new(new ClrFunctionInstance(Engine, "throw", Throw, 1, LengthFlags), PropertyFlags)
         };
         SetProperties(properties);
 
@@ -50,7 +50,7 @@ protected override void Initialize()
     private JsValue Next(JsValue thisObject, JsValue[] arguments)
     {
         var g = AssertGeneratorInstance(thisObject);
-        var value = arguments.At(0);
+        var value = arguments.At(0, null!);
         return g.GeneratorResume(value, null);
     }
 
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/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/JintYieldExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintYieldExpression.cs
@@ -15,13 +15,20 @@ public JintYieldExpression(YieldExpression expression) : base(expression)
     protected override object EvaluateInternal(EvaluationContext context)
     {
         var expression = (YieldExpression) _expression;
-        var engine = context.Engine;
 
-        var value = JsValue.Undefined;
-        if (expression.Argument is not null)
+        JsValue value;
+        if (context.Engine.ExecutionContext.Generator?._nextValue is not null)
+        {
+            value = context.Engine.ExecutionContext.Generator._nextValue;
+        }
+        else if (expression.Argument is not null)
         {
             value = Build(expression.Argument).GetValue(context);
         }
+        else
+        {
+            value = JsValue.Undefined;
+        }
 
         if (expression.Delegate)
         {
diff --git a/Jint/Runtime/Interpreter/JintStatementList.cs b/Jint/Runtime/Interpreter/JintStatementList.cs
@@ -20,7 +20,7 @@ private sealed class Pair
 
         private Pair[]? _jintStatements;
         private bool _initialized;
-        private readonly uint _index;
+        private uint _index;
         private readonly bool _generator;
 
         public JintStatementList(IFunction function)
@@ -102,10 +102,13 @@ public Completion Execute(EvaluationContext context)
                         }
                     }
 
-                    if (_generator && context.Engine.ExecutionContext.Generator?._generatorState == GeneratorState.SuspendedYield)
+                    if (_generator)
                     {
-                        _index = i + 1;
-                        return new Completion(CompletionType.Return, c.Value, s._statement);
+                        if (context.Engine.ExecutionContext.Generator?._generatorState == GeneratorState.SuspendedYield)
+                        {
+                            _index = i + 1;
+                            return new Completion(CompletionType.Return, c.Value, s._statement);
+                        }
                     }
 
                     if (c.Type != CompletionType.Normal)
diff --git a/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs b/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs
@@ -18,7 +18,7 @@ protected override void Initialize(EvaluationContext context)
             _lexicalDeclarations = HoistingScope.GetLexicalDeclarations(_statement);
         }
 
-        internal override bool SupportsResume => true;
+        internal bool SupportsResume => true;
 
         /// <summary>
         /// Optimized for direct access without virtual dispatch.
diff --git a/Jint/Runtime/Interpreter/Statements/JintStatement.cs b/Jint/Runtime/Interpreter/Statements/JintStatement.cs
diff --git a/Jint/Runtime/Interpreter/Statements/JintTryStatement.cs b/Jint/Runtime/Interpreter/Statements/JintTryStatement.cs

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ internal sealed class GeneratorInstance : ObjectInstance`
`15`	`15`	`private ExecutionContext _generatorContext;`
`16`	`16`	`private readonly JsValue? _generatorBrand = null;`
`17`	`17`	`private JintStatementList _generatorBody = null!;`
	`18`	`+ public JsValue? _nextValue;`
`18`	`19`
`19`	`20`	`public GeneratorInstance(Engine engine) : base(engine)`
`20`	`21`	`{`
`@@ -50,6 +51,8 @@ public JsValue GeneratorResume(JsValue value, JsValue? generatorBrand)`
`50`	`51`
`51`	`52`	`// 6. Suspend methodContext.`
`52`	`53`
	`54`	`+ _nextValue = value;`
	`55`	`+`
`53`	`56`	`var context = _engine._activeEvaluationContext;`
`54`	`57`	`return ResumeExecution(genContext, context!);`
`55`	`58`	`}`
`@@ -79,9 +82,10 @@ public JsValue GeneratorResumeAbrupt(in Completion abruptCompletion, JsValue? ge`
`79`	`82`	`var genContext = _generatorContext;`
`80`	`83`	`var methodContext = _engine.ExecutionContext;`
`81`	`84`
`82`		`- // Suspend methodContext.`
	`85`	`+ // Suspend methodContext`
	`86`	`+ _nextValue = abruptCompletion.Value;`
`83`	`87`
`84`		`- return ResumeExecution(genContext, new EvaluationContext(_engine, abruptCompletion));`
	`88`	`+ return ResumeExecution(genContext, new EvaluationContext(_engine));`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`private JsValue ResumeExecution(ExecutionContext genContext, EvaluationContext context)`
`@@ -92,19 +96,24 @@ private JsValue ResumeExecution(ExecutionContext genContext, EvaluationContext c`
`92`	`96`	`var result = _generatorBody.Execute(context);`
`93`	`97`	`_engine.LeaveExecutionContext();`
`94`	`98`
	`99`	`+ _nextValue = null;`
	`100`	`+`
`95`	`101`	`ObjectInstance? resultValue = null;`
`96`	`102`	`if (result.Type == CompletionType.Normal)`
`97`	`103`	`{`
`98`	`104`	`_generatorState = GeneratorState.Completed;`
`99`		`- var value = context.ResumedCompletion.GetValueOrDefault();`
`100`		`- resultValue = IteratorInstance.ValueIteratorPosition.Done(_engine, value);`
	`105`	`+ resultValue = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, done: JsBoolean.True);`
`101`	`106`	`}`
`102`	`107`	`else if (result.Type == CompletionType.Return)`
`103`	`108`	`{`
`104`		`- resultValue = new IteratorInstance.ValueIteratorPosition(_engine, result.Value, false);`
`105`		`- if (_generatorBody.Completed)`
	`109`	`+ if (_generatorState == GeneratorState.SuspendedYield)`
	`110`	`+ {`
	`111`	`+ resultValue = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, done: JsBoolean.False);`
	`112`	`+ }`
	`113`	`+ else`
`106`	`114`	`{`
`107`	`115`	`_generatorState = GeneratorState.Completed;`
	`116`	`+ resultValue = IteratorResult.CreateValueIteratorPosition(_engine, null!, done: JsBoolean.True);`
`108`	`117`	`}`
`109`	`118`	`}`
`110`	`119`
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`
Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,20 @@ public JintYieldExpression(YieldExpression expression) : base(expression)`
`15`	`15`	`protected override object EvaluateInternal(EvaluationContext context)`
`16`	`16`	`{`
`17`	`17`	`var expression = (YieldExpression) _expression;`
`18`		`- var engine = context.Engine;`
`19`	`18`
`20`		`- var value = JsValue.Undefined;`
`21`		`- if (expression.Argument is not null)`
	`19`	`+ JsValue value;`
	`20`	`+ if (context.Engine.ExecutionContext.Generator?._nextValue is not null)`
	`21`	`+ {`
	`22`	`+ value = context.Engine.ExecutionContext.Generator._nextValue;`
	`23`	`+ }`
	`24`	`+ else if (expression.Argument is not null)`
`22`	`25`	`{`
`23`	`26`	`value = Build(expression.Argument).GetValue(context);`
`24`	`27`	`}`
	`28`	`+ else`
	`29`	`+ {`
	`30`	`+ value = JsValue.Undefined;`
	`31`	`+ }`
`25`	`32`
`26`	`33`	`if (expression.Delegate)`
`27`	`34`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ private sealed class Pair`
`20`	`20`
`21`	`21`	`private Pair[]? _jintStatements;`
`22`	`22`	`private bool _initialized;`
`23`		`- private readonly uint _index;`
	`23`	`+ private uint _index;`
`24`	`24`	`private readonly bool _generator;`
`25`	`25`
`26`	`26`	`public JintStatementList(IFunction function)`
`@@ -102,10 +102,13 @@ public Completion Execute(EvaluationContext context)`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`- if (_generator && context.Engine.ExecutionContext.Generator?._generatorState == GeneratorState.SuspendedYield)`
	`105`	`+ if (_generator)`
`106`	`106`	`{`
`107`		`- _index = i + 1;`
`108`		`- return new Completion(CompletionType.Return, c.Value, s._statement);`
	`107`	`+ if (context.Engine.ExecutionContext.Generator?._generatorState == GeneratorState.SuspendedYield)`
	`108`	`+ {`
	`109`	`+ _index = i + 1;`
	`110`	`+ return new Completion(CompletionType.Return, c.Value, s._statement);`
	`111`	`+ }`
`109`	`112`	`}`
`110`	`113`
`111`	`114`	`if (c.Type != CompletionType.Normal)`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ protected override void Initialize(EvaluationContext context)`
`18`	`18`	`_lexicalDeclarations = HoistingScope.GetLexicalDeclarations(_statement);`
`19`	`19`	`}`
`20`	`20`
`21`		`- internal override bool SupportsResume => true;`
	`21`	`+ internal bool SupportsResume => true;`
`22`	`22`
`23`	`23`	`/// <summary>`
`24`	`24`	`/// Optimized for direct access without virtual dispatch.`