ES6 generators

sebastienros · Dec 31, 2023 · fedcf93 · fedcf93
1 parent 84cd41a
commit fedcf93
Show file tree

Hide file tree

Showing 16 changed files with 676 additions and 49 deletions.
diff --git a/Jint.Tests.Test262/Test262Harness.settings.json b/Jint.Tests.Test262/Test262Harness.settings.json
@@ -9,7 +9,6 @@
     "arraybuffer-transfer",
     "async-iteration",
     "Atomics",
-    "generators",
     "import-assertions",
     "import-attributes",
     "iterator-helpers",

diff --git a/Jint.Tests/Runtime/AwaitTests.cs b/Jint.Tests/Runtime/AwaitTests.cs
@@ -78,4 +78,36 @@ public void ShouldTaskAwaitCurrentStack()
         engine.Execute("async function hello() {await myAsyncMethod();myAsyncMethod2();} hello();");
         Assert.Equal("12", log);
     }
+
+    [Fact(Skip = "TODO 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.Tests/Runtime/GeneratorTests.cs b/Jint.Tests/Runtime/GeneratorTests.cs
@@ -0,0 +1,256 @@
+namespace Jint.Tests.Runtime;
+
+public class GeneratorTests
+{
+    [Fact]
+    public void LoopYield()
+    {
+        const string Script = """
+          const foo = function*() {
+            yield 'a';
+            yield 'b';
+            yield 'c';
+          };
+
+          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()
+    {
+        var engine = new Engine();
+        engine.Execute("function * generator() { yield 5; yield 6; };");
+        engine.Execute("var iterator = generator(); var item = iterator.next();");
+        Assert.Equal(5, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.Equal(6, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.True(engine.Evaluate("item.value === void undefined").AsBoolean());
+        Assert.True(engine.Evaluate("item.done").AsBoolean());
+    }
+
+    [Fact]
+    public void FunctionExpressions()
+    {
+        var engine = new Engine();
+        engine.Execute("var generator = function * () { yield 5; yield 6; };");
+        engine.Execute("var iterator = generator(); var item = iterator.next();");
+        Assert.Equal(5, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.Equal(6, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.True(engine.Evaluate("item.value === void undefined").AsBoolean());
+        Assert.True(engine.Evaluate("item.done").AsBoolean());
+    }
+
+    [Fact]
+    public void CorrectThisBinding()
+    {
+        var engine = new Engine();
+        engine.Execute("var generator = function * () { yield 5; yield 6; };");
+        engine.Execute("var iterator = { g: generator, x: 5, y: 6 }.g(); var item = iterator.next();");
+        Assert.Equal(5, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.Equal(6, engine.Evaluate("item.value"));
+        Assert.False(engine.Evaluate("item.done").AsBoolean());
+        engine.Execute("item = iterator.next();");
+        Assert.True(engine.Evaluate("item.value === void undefined").AsBoolean());
+        Assert.True(engine.Evaluate("item.done").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);
+
+        Assert.Equal("foo", engine.Evaluate("sent[0]"));
+        Assert.Equal("bar", engine.Evaluate("sent[1]"));
+    }
+
+    [Fact(Skip = "WIP")]
+    public void Sending2()
+    {
+        const string Script = """
+        function* counter(value) {
+          while (true) {
+            const step = yield value++;
+
+            if (step) {
+              value += step;
+            }
+          }
+        }
+
+        const generatorFunc = counter(0);
+        """;
+
+        var engine = new Engine();
+        engine.Execute(Script);
+
+        Assert.Equal(0, engine.Evaluate("generatorFunc.next().value")); // 0
+        Assert.Equal(1, engine.Evaluate("generatorFunc.next().value")); // 1
+        Assert.Equal(2, engine.Evaluate("generatorFunc.next().value")); // 2
+        Assert.Equal(3, engine.Evaluate("generatorFunc.next().value")); // 3
+        Assert.Equal(14, engine.Evaluate("generatorFunc.next(10).value")); // 14
+        Assert.Equal(15, engine.Evaluate("generatorFunc.next().value")); // 15
+        Assert.Equal(26, engine.Evaluate("generatorFunc.next(10).value")); // 26
+    }
+
+    [Fact(Skip = "WIP")]
+    public void Fibonacci()
+    {
+        const string Script = """
+            function* fibonacci() {
+              let current = 0;
+              let next = 1;
+              while (true) {
+                const reset = yield current;
+                [current, next] = [next, next + current];
+                if (reset) {
+                  current = 0;
+                  next = 1;
+                }
+              }
+            }
+
+            const sequence = fibonacci();
+        """;
+
+        var engine = new Engine();
+        engine.Execute(Script);
+
+        Assert.Equal(0, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(1, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(1, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(2, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(3, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(5, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(9, engine.Evaluate("sequence.next().value"));
+        Assert.Equal(0, engine.Evaluate("sequence.next(true).value"));
+        Assert.Equal(1, engine.Evaluate("sequence.next().value)"));
+        Assert.Equal(1, engine.Evaluate("sequence.next().value)"));
+        Assert.Equal(2, engine.Evaluate("sequence.next().value)"));
+    }
+}
diff --git a/Jint/Native/Function/FunctionConstructor.cs b/Jint/Native/Function/FunctionConstructor.cs
@@ -113,8 +113,24 @@ private ScriptFunctionInstance InstantiateGeneratorFunctionObject(
             EnvironmentRecord scope,
             PrivateEnvironmentRecord? 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;
 
@@ -42,6 +43,8 @@ internal FunctionInstance 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());
@@ -161,7 +164,8 @@ internal FunctionInstance 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/Function/FunctionInstance.cs b/Jint/Native/Function/FunctionInstance.cs
@@ -330,6 +330,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/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));