Assignment fixes and more tests (#716)

Jint.Tests.Ecma/TestCases/alltests.json

@@ -18220,8 +18220,8 @@
     source: "ch15/15.1/15.1.2/15.1.2.4/S15.1.2.4_A2.1.js"
   },
   {
-    skip: false,
-    reason: "",
+    skip: true,
+    reason: "spec has changed",
     source: "ch15/15.1/15.1.2/15.1.2.4/S15.1.2.4_A2.2.js"
   },
   {
@@ -18265,8 +18265,8 @@
     source: "ch15/15.1/15.1.2/15.1.2.5/S15.1.2.5_A2.1.js"
   },
   {
-    skip: false,
-    reason: "",
+    skip: true,
+    reason: "spec has changed",
     source: "ch15/15.1/15.1.2/15.1.2.5/S15.1.2.5_A2.2.js"
   },
   {

Jint.Tests.Test262/ArrayTests.cs → Jint.Tests.Test262/BuiltIns/ArrayTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ArrayTests : Test262Test
     {

Jint.Tests.Test262/BooleanTests.cs → Jint.Tests.Test262/BuiltIns/BooleanTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class BooleanTests : Test262Test
     {

Jint.Tests.Test262/DateTests.cs → Jint.Tests.Test262/BuiltIns/DateTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class DateTests : Test262Test
     {

Jint.Tests.Test262/BuiltIns/DecodeUriComponentTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class DecodeUriComponentTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\decodeURIComponent")]
+        [MemberData(nameof(SourceFiles), "built-ins\\decodeURIComponent", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\decodeURIComponent", true, Skip = "Skipped")]
+        protected void DecodeUriComponent(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/DecodeUriTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class DecodeUriTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\decodeURI")]
+        [MemberData(nameof(SourceFiles), "built-ins\\decodeURI", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\decodeURI", true, Skip = "Skipped")]
+        protected void DecodeUri(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/EncodeUriComponentTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class EncodeUriComponentTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\encodeURIComponent")]
+        [MemberData(nameof(SourceFiles), "built-ins\\encodeURIComponent", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\encodeURIComponent", true, Skip = "Skipped")]
+        protected void EncodeUriComponent(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/EncodeUriTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class EncodeUriTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\encodeURI")]
+        [MemberData(nameof(SourceFiles), "built-ins\\encodeURI", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\encodeURI", true, Skip = "Skipped")]
+        protected void EncodeUri(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/GlobalTests.cs → Jint.Tests.Test262/BuiltIns/GlobalTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class GlobalTests : Test262Test
     {

Jint.Tests.Test262/BuiltIns/InfinityTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class InfinityTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\Infinity")]
+        [MemberData(nameof(SourceFiles), "built-ins\\Infinity", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\Infinity", true, Skip = "Skipped")]
+        protected void RunTest(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/IsFiniteTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class IsFiniteTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\isFinite")]
+        [MemberData(nameof(SourceFiles), "built-ins\\isFinite", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\isFinite", true, Skip = "Skipped")]
+        protected void RunTest(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/IsNaNTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class IsNaNTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\isNaN")]
+        [MemberData(nameof(SourceFiles), "built-ins\\isNaN", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\isNaN", true, Skip = "Skipped")]
+        protected void RunTest(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/MapTests.cs → Jint.Tests.Test262/BuiltIns/MapTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class MapTests : Test262Test
     {

Jint.Tests.Test262/MathTests.cs → Jint.Tests.Test262/BuiltIns/MathTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class MathTests : Test262Test
     {

Jint.Tests.Test262/BuiltIns/NaNTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class NaNTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\NaN")]
+        [MemberData(nameof(SourceFiles), "built-ins\\NaN", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\NaN", true, Skip = "Skipped")]
+        protected void RunTest(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/NumberTests.cs → Jint.Tests.Test262/BuiltIns/NumberTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class NumberTests : Test262Test
     {

Jint.Tests.Test262/ObjectTests.cs → Jint.Tests.Test262/BuiltIns/ObjectTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ObjectTests : Test262Test
     {

Jint.Tests.Test262/ParseFloatTests.cs → Jint.Tests.Test262/BuiltIns/ParseFloatTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ParseFloatTests : Test262Test
     {

Jint.Tests.Test262/ParseIntTests.cs → Jint.Tests.Test262/BuiltIns/ParseIntTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ParseIntTests : Test262Test
     {

Jint.Tests.Test262/ProxyTests.cs → Jint.Tests.Test262/BuiltIns/ProxyTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ProxyTests : Test262Test
     {

Jint.Tests.Test262/ReflectTests.cs → Jint.Tests.Test262/BuiltIns/ReflectTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class ReflectTests : Test262Test
     {

Jint.Tests.Test262/RegExpTests.cs → Jint.Tests.Test262/BuiltIns/RegExpTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class RegExpTests : Test262Test
     {

Jint.Tests.Test262/SetTests.cs → Jint.Tests.Test262/BuiltIns/SetTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class SetTests : Test262Test
     {

Jint.Tests.Test262/BuiltIns/StringIteratorPrototypeTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class StringIteratorPrototypeTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\StringIteratorPrototype")]
+        [MemberData(nameof(SourceFiles), "built-ins\\StringIteratorPrototype", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\StringIteratorPrototype", true, Skip = "Skipped")]
+        protected void StringIteratorPrototype(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/BuiltIns/StringTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class StringTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\String")]
+        [MemberData(nameof(SourceFiles), "built-ins\\String", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\String", true, Skip = "Skipped")]
+        protected void String(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/SymbolTests.cs → Jint.Tests.Test262/BuiltIns/SymbolTests.cs

@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace Jint.Tests.Test262
+namespace Jint.Tests.Test262.BuiltIns
 {
     public class SymbolTests : Test262Test
     {

Jint.Tests.Test262/BuiltIns/UndefinedTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.BuiltIns
+{
+    public class UndefinedTests : Test262Test
+    {
+        [Theory(DisplayName = "built-ins\\undefined")]
+        [MemberData(nameof(SourceFiles), "built-ins\\undefined", false)]
+        [MemberData(nameof(SourceFiles), "built-ins\\undefined", true, Skip = "Skipped")]
+        protected void RunTest(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/CommentsTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class CommentsTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\comments")]
+        [MemberData(nameof(SourceFiles), "language\\comments", false)]
+        [MemberData(nameof(SourceFiles), "language\\comments", true, Skip = "Skipped")]
+        protected void Comments(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/DestructuringTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class DestructuringTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\destructuring")]
+        [MemberData(nameof(SourceFiles), "language\\destructuring", false)]
+        [MemberData(nameof(SourceFiles), "language\\destructuring", true, Skip = "Skipped")]
+        protected void Destructuring(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/AdditionTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class AdditionTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\addition")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\addition", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\addition", true, Skip = "Skipped")]
+        protected void Addition(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/ArrayTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class ArrayTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\array")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\array", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\array", true, Skip = "Skipped")]
+        protected void Array(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/ArrowFunctionTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class ArrowFunctionTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\arrow-function")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\arrow-function", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\arrow-function", true, Skip = "Skipped")]
+        protected void ArrowFunction(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/AssignmentTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class AssignmentTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\assignment")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\assignment", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\assignment", true, Skip = "Skipped")]
+        protected void Assignment(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/CallTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class CallTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\call")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\call", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\call", true, Skip = "Skipped")]
+        protected void Call(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/FunctionTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class FunctionTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\function")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\function", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\function", true, Skip = "Skipped")]
+        protected void Function(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/NewTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class NewTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\new")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\new", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\new", true, Skip = "Skipped")]
+        protected void New(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/ObjectTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class ObjectTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\object")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\object", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\object", true, Skip = "Skipped")]
+        protected void Object(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Expressions/TemplateLiteralTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Expressions
+{
+    public class TemplateLiteralTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\expressions\\template-literal")]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\template-literal", false)]
+        [MemberData(nameof(SourceFiles), "language\\expressions\\template-literal", true, Skip = "Skipped")]
+        protected void TemplateLiteral(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/RestParametersTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class RestParametersTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\rest-parameters")]
+        [MemberData(nameof(SourceFiles), "language\\rest-parameters", false)]
+        [MemberData(nameof(SourceFiles), "language\\rest-parameters", true, Skip = "Skipped")]
+        protected void RestParameters(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/SourceTextTests.cs

@@ -0,0 +1,16 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class SourceTextTests : Test262Test
+    {
+
+        [Theory(DisplayName = "language\\source-text")]
+        [MemberData(nameof(SourceFiles), "language\\source-text", false)]
+        [MemberData(nameof(SourceFiles), "language\\source-text", true, Skip = "Skipped")]
+        protected void SourceText(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Statements/ForInTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Statements
+{
+    public class ForInTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\statements\\for-in")]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for-in", false)]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for-in", true, Skip = "Skipped")]
+        protected void ForIn(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Statements/ForOfTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Statements
+{
+    public class ForOfTests : Test262Test
+    {
+        [Theory(Skip = "for of not implemented", DisplayName = "language\\statements\\for-of")]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for-of", false)]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for-of", true, Skip = "Skipped")]
+        protected void ForOf(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/Statements/ForTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language.Statements
+{
+    public class ForTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\statements\\for")]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for", false)]
+        [MemberData(nameof(SourceFiles), "language\\statements\\for", true, Skip = "Skipped")]
+        protected void For(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/TypesTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class TypesTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\types")]
+        [MemberData(nameof(SourceFiles), "language\\types", false)]
+        [MemberData(nameof(SourceFiles), "language\\types", true, Skip = "Skipped")]
+        protected void Types(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/Language/WhiteSpaceTests.cs

@@ -0,0 +1,15 @@
+using Xunit;
+
+namespace Jint.Tests.Test262.Language
+{
+    public class WhiteSpaceTests : Test262Test
+    {
+        [Theory(DisplayName = "language\\white-space")]
+        [MemberData(nameof(SourceFiles), "language\\white-space", false)]
+        [MemberData(nameof(SourceFiles), "language\\white-space", true, Skip = "Skipped")]
+        protected void WhiteSpace(SourceFile sourceFile)
+        {
+            RunTestInternal(sourceFile);
+        }
+    }
+}

Jint.Tests.Test262/LanguageTests.cs

@@ -1,103 +0,0 @@
-using Xunit;
-
-namespace Jint.Tests.Test262
-{
-    public class LanguageTests : Test262Test
-    {
-        [Theory(DisplayName = "language\\rest-parameters")]
-        [MemberData(nameof(SourceFiles), "language\\rest-parameters", false)]
-        [MemberData(nameof(SourceFiles), "language\\rest-parameters", true, Skip = "Skipped")]
-        protected void RestParameters(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\destructuring")]
-        [MemberData(nameof(SourceFiles), "language\\destructuring", false)]
-        [MemberData(nameof(SourceFiles), "language\\destructuring", true, Skip = "Skipped")]
-        protected void Destructuring(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\array")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\array", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\array", true, Skip = "Skipped")]
-        protected void ExpressionsArray(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\arrow-function")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\arrow-function", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\arrow-function", true, Skip = "Skipped")]
-        protected void ArrowFunction(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\function")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\function", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\function", true, Skip = "Skipped")]
-        protected void Function(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\call")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\call", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\call", true, Skip = "Skipped")]
-        protected void ExpressionsCall(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\new")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\new", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\new", true, Skip = "Skipped")]
-        protected void ExpressionsNew(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\object")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\object", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\object", true, Skip = "Skipped")]
-        protected void ExpressionsObject(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\expressions\\template-literal")]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\template-literal", false)]
-        [MemberData(nameof(SourceFiles), "language\\expressions\\template-literal", true, Skip = "Skipped")]
-        protected void ExpressionsTemplateLiteral(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\source-text")]
-        [MemberData(nameof(SourceFiles), "language\\source-text", false)]
-        [MemberData(nameof(SourceFiles), "language\\source-text", true, Skip = "Skipped")]
-        protected void SourceText(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\types")]
-        [MemberData(nameof(SourceFiles), "language\\types", false)]
-        [MemberData(nameof(SourceFiles), "language\\types", true, Skip = "Skipped")]
-        protected void Types(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\white-space")]
-        [MemberData(nameof(SourceFiles), "language\\white-space", false)]
-        [MemberData(nameof(SourceFiles), "language\\white-space", true, Skip = "Skipped")]
-        protected void WhiteSpace(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-    }
-}

Jint.Tests.Test262/StatementTests.cs

@@ -1,31 +0,0 @@
-using Xunit;
-
-namespace Jint.Tests.Test262
-{
-    public class StatementTests : Test262Test
-    {
-        [Theory(DisplayName = "language\\statements\\for")]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for", false)]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for", true, Skip = "Skipped")]
-        protected void For(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "language\\statements\\for-in")]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for-in", false)]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for-in", true, Skip = "Skipped")]
-        protected void ForIn(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(Skip = "for of not implemented", DisplayName = "language\\statements\\for-of")]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for-of", false)]
-        [MemberData(nameof(SourceFiles), "language\\statements\\for-of", true, Skip = "Skipped")]
-        protected void ForOf(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-    }
-}

Jint.Tests.Test262/StringTests.cs

@@ -1,23 +0,0 @@
-using Xunit;
-
-namespace Jint.Tests.Test262
-{
-    public class StringTests : Test262Test
-    {
-        [Theory(DisplayName = "built-ins\\String")]
-        [MemberData(nameof(SourceFiles), "built-ins\\String", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\String", true, Skip = "Skipped")]
-        protected void String(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "built-ins\\StringIteratorPrototype")]
-        [MemberData(nameof(SourceFiles), "built-ins\\StringIteratorPrototype", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\StringIteratorPrototype", true, Skip = "Skipped")]
-        protected void StringIteratorPrototype(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-    }
-}

Jint.Tests.Test262/Test262Test.cs

@@ -195,6 +195,10 @@ namespace Jint.Tests.Test262
                                 skip = true;
                                 reason = "class keyword not implemented";
                                 break;
+                            case "const":
+                                skip = true;
+                                reason = "const keyword not implemented";
+                                break;
                             case "BigInt":
                                 skip = true;
                                 reason = "BigInt not implemented";

Jint.Tests.Test262/UriTests.cs

@@ -1,39 +0,0 @@
-using Xunit;
-
-namespace Jint.Tests.Test262
-{
-    public class UriTests : Test262Test
-    {
-        [Theory(DisplayName = "built-ins\\decodeURI")]
-        [MemberData(nameof(SourceFiles), "built-ins\\decodeURI", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\decodeURI", true, Skip = "Skipped")]
-        protected void DecodeUri(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "built-ins\\decodeURIComponent")]
-        [MemberData(nameof(SourceFiles), "built-ins\\decodeURIComponent", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\decodeURIComponent", true, Skip = "Skipped")]
-        protected void DecodeUriComponent(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "built-ins\\encodeURI")]
-        [MemberData(nameof(SourceFiles), "built-ins\\encodeURI", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\encodeURI", true, Skip = "Skipped")]
-        protected void EncodeUri(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-
-        [Theory(DisplayName = "built-ins\\encodeURIComponent")]
-        [MemberData(nameof(SourceFiles), "built-ins\\encodeURIComponent", false)]
-        [MemberData(nameof(SourceFiles), "built-ins\\encodeURIComponent", true, Skip = "Skipped")]
-        protected void EncodeUriComponent(SourceFile sourceFile)
-        {
-            RunTestInternal(sourceFile);
-        }
-    }
-}

Jint.Tests.Test262/test/skipped.json

@@ -1,4 +1,8 @@
 [
+  {
+    "source": "language/expressions/assignment/fn-name-lhs-cover.js",
+    "reason": "Currently quite impossible to detect if assignment target is CoverParenthesizedExpression"
+  },
   {
     "source": "built-ins/RegExp/character-class-escape-non-whitespace.js",
     "reason": "Unicode support not built-in to .NET the same way, requires more work"
@@ -359,6 +363,10 @@
     "source": "built-ins/Math/pow/int32_min-exponent.js",
     "reason": "const not implemented"
   },
+  {
+    "source": "language/expressions/assignment/dstr-obj-rest-put-const.js",
+    "reason": "const not implemented"
+  },
   {
     "source": "language/expressions/template-literal/tv-line-terminator-sequence.js",
     "reason": "Line feed problems (git, windows, linux)"
@@ -383,6 +391,18 @@
   },
 
   // let support
+  {
+    "source": "language/expressions/assignment/dstr-array-rest-nested-obj-undefined-own.js",
+    "reason": "let not implemented"
+  },
+  {
+    "source": "language/expressions/assignment/dstr-array-rest-nested-obj-undefined.js",
+    "reason": "let not implemented"
+  },
+  {
+    "source": "language/expressions/assignment/dstr-array-rest-nested-obj-undefined-hole.js",
+    "reason": "let not implemented"
+  },
   {
     "source": "language/statements/for/dstr-const-ary-ptrn-rest-obj-prop-id.js",
     "reason": "let not implemented"
@@ -860,4 +880,8 @@
     "source": "language/expressions/object/let-non-strict-syntax.js",
     "reason": "Esprima problem"
   },
+  {
+    "source": "language/expressions/assignment/dstr-obj-id-identifier-yield-ident-valid.js",
+    "reason": "Esprima problem"
+  },
 ]

Jint/Native/Global/GlobalObject.cs

@@ -29,48 +29,49 @@ namespace Jint.Native.Global
 
         protected override void Initialize()
         {
-            const PropertyFlag defaultFlags = PropertyFlag.Configurable | PropertyFlag.Writable;
+            const PropertyFlag lengthFlags = PropertyFlag.Configurable;
+            const PropertyFlag propertyFlags = PropertyFlag.Configurable | PropertyFlag.Writable;
             var properties = new PropertyDictionary(40, checkExistingKeys: false)
             {
-                ["Object"] = new PropertyDescriptor(Engine.Object, defaultFlags),
-                ["Function"] = new PropertyDescriptor(Engine.Function, defaultFlags),
-                ["Symbol"] = new PropertyDescriptor(Engine.Symbol, defaultFlags),
-                ["Array"] = new PropertyDescriptor(Engine.Array, defaultFlags),
-                ["Map"] = new PropertyDescriptor(Engine.Map, defaultFlags),
-                ["Set"] = new PropertyDescriptor(Engine.Set, defaultFlags),
-                ["String"] = new PropertyDescriptor(Engine.String, defaultFlags),
-                ["RegExp"] = new PropertyDescriptor(Engine.RegExp, defaultFlags),
-                ["Number"] = new PropertyDescriptor(Engine.Number, defaultFlags),
-                ["Boolean"] = new PropertyDescriptor(Engine.Boolean, defaultFlags),
-                ["Date"] = new PropertyDescriptor(Engine.Date, defaultFlags),
-                ["Math"] = new PropertyDescriptor(Engine.Math, defaultFlags),
-                ["JSON"] = new PropertyDescriptor(Engine.Json, defaultFlags),
-                ["Error"] = new LazyPropertyDescriptor(() => Engine.Error, defaultFlags),
-                ["EvalError"] = new LazyPropertyDescriptor(() => Engine.EvalError, defaultFlags),
-                ["Proxy"] = new LazyPropertyDescriptor(() => Engine.Proxy, defaultFlags),
-                ["RangeError"] = new LazyPropertyDescriptor(() => Engine.RangeError, defaultFlags),
-                ["ReferenceError"] = new LazyPropertyDescriptor(() => Engine.ReferenceError, defaultFlags),
-                ["Reflect"] = new LazyPropertyDescriptor(() => Engine.Reflect, defaultFlags),
-                ["SyntaxError"] = new LazyPropertyDescriptor(() => Engine.SyntaxError, defaultFlags),
-                ["TypeError"] = new LazyPropertyDescriptor(() => Engine.TypeError, defaultFlags),
-                ["URIError"] = new LazyPropertyDescriptor(() => Engine.UriError, defaultFlags),
+                ["Object"] = new PropertyDescriptor(Engine.Object, propertyFlags),
+                ["Function"] = new PropertyDescriptor(Engine.Function, propertyFlags),
+                ["Symbol"] = new PropertyDescriptor(Engine.Symbol, propertyFlags),
+                ["Array"] = new PropertyDescriptor(Engine.Array, propertyFlags),
+                ["Map"] = new PropertyDescriptor(Engine.Map, propertyFlags),
+                ["Set"] = new PropertyDescriptor(Engine.Set, propertyFlags),
+                ["String"] = new PropertyDescriptor(Engine.String, propertyFlags),
+                ["RegExp"] = new PropertyDescriptor(Engine.RegExp, propertyFlags),
+                ["Number"] = new PropertyDescriptor(Engine.Number, propertyFlags),
+                ["Boolean"] = new PropertyDescriptor(Engine.Boolean, propertyFlags),
+                ["Date"] = new PropertyDescriptor(Engine.Date, propertyFlags),
+                ["Math"] = new PropertyDescriptor(Engine.Math, propertyFlags),
+                ["JSON"] = new PropertyDescriptor(Engine.Json, propertyFlags),
+                ["Error"] = new LazyPropertyDescriptor(() => Engine.Error, propertyFlags),
+                ["EvalError"] = new LazyPropertyDescriptor(() => Engine.EvalError, propertyFlags),
+                ["Proxy"] = new LazyPropertyDescriptor(() => Engine.Proxy, propertyFlags),
+                ["RangeError"] = new LazyPropertyDescriptor(() => Engine.RangeError, propertyFlags),
+                ["ReferenceError"] = new LazyPropertyDescriptor(() => Engine.ReferenceError, propertyFlags),
+                ["Reflect"] = new LazyPropertyDescriptor(() => Engine.Reflect, propertyFlags),
+                ["SyntaxError"] = new LazyPropertyDescriptor(() => Engine.SyntaxError, propertyFlags),
+                ["TypeError"] = new LazyPropertyDescriptor(() => Engine.TypeError, propertyFlags),
+                ["URIError"] = new LazyPropertyDescriptor(() => Engine.UriError, propertyFlags),
                 ["NaN"] = new PropertyDescriptor(double.NaN, PropertyFlag.None),
                 ["Infinity"] = new PropertyDescriptor(double.PositiveInfinity, PropertyFlag.None),
                 ["undefined"] = new PropertyDescriptor(Undefined, PropertyFlag.None),
-                ["parseInt"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "parseInt", ParseInt, 2, PropertyFlag.Configurable), defaultFlags),
-                ["parseFloat"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "parseFloat", ParseFloat, 1, PropertyFlag.Configurable), defaultFlags),
-                ["isNaN"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "isNaN", IsNaN, 1), defaultFlags),
-                ["isFinite"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "isFinite", IsFinite, 1), defaultFlags),
-                ["decodeURI"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "decodeURI", DecodeUri, 1, PropertyFlag.Configurable), defaultFlags),
-                ["decodeURIComponent"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "decodeURIComponent", DecodeUriComponent, 1, PropertyFlag.Configurable), defaultFlags),
-                ["encodeURI"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "encodeURI", EncodeUri, 1, PropertyFlag.Configurable), defaultFlags),
-                ["encodeURIComponent"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "encodeURIComponent", EncodeUriComponent, 1, PropertyFlag.Configurable), defaultFlags),
-                ["escape"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "escape", Escape, 1), defaultFlags),
-                ["unescape"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "unescape", Unescape, 1), defaultFlags),
-                ["globalThis"] = new PropertyDescriptor(this, defaultFlags),
+                ["parseInt"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "parseInt", ParseInt, 2, lengthFlags), propertyFlags),
+                ["parseFloat"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "parseFloat", ParseFloat, 1, lengthFlags), propertyFlags),
+                ["isNaN"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "isNaN", IsNaN, 1, lengthFlags), propertyFlags),
+                ["isFinite"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "isFinite", IsFinite, 1, lengthFlags), propertyFlags),
+                ["decodeURI"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "decodeURI", DecodeUri, 1, lengthFlags), propertyFlags),
+                ["decodeURIComponent"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "decodeURIComponent", DecodeUriComponent, 1, lengthFlags), propertyFlags),
+                ["encodeURI"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "encodeURI", EncodeUri, 1, lengthFlags), propertyFlags),
+                ["encodeURIComponent"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "encodeURIComponent", EncodeUriComponent, 1, lengthFlags), propertyFlags),
+                ["escape"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "escape", Escape, 1), propertyFlags),
+                ["unescape"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "unescape", Unescape, 1), propertyFlags),
+                ["globalThis"] = new PropertyDescriptor(this, propertyFlags),
 
                 // toString is not mentioned or actually required in spec, but some tests rely on it
-                ["toString"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "toString", ToStringString, 1), defaultFlags)
+                ["toString"] = new PropertyDescriptor(new ClrFunctionInstance(Engine, "toString", ToStringString, 1), propertyFlags)
             };
 
             SetProperties(properties);

Jint/Native/Iterator/IIterator.cs

@@ -1,10 +1,11 @@
 using Jint.Native.Object;
+using Jint.Runtime;
 
 namespace Jint.Native.Iterator
 {
     public interface IIterator
     {
-        ObjectInstance Next();
-        void Return();
+        bool TryIteratorStep(out ObjectInstance nextItem);
+        void Close(CompletionType completion);
     }
 }

Jint/Native/Iterator/IteratorInstance.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
+
 using Jint.Native.Array;
 using Jint.Native.Map;
 using Jint.Native.Object;
@@ -36,17 +38,19 @@ namespace Jint.Native.Iterator
             return false;
         }
 
-        public virtual ObjectInstance Next()
+        public virtual bool TryIteratorStep(out ObjectInstance nextItem)
         {
             if (_enumerable.MoveNext())
             {
-                return new ValueIteratorPosition(_engine, _enumerable.Current);
+                nextItem = new ValueIteratorPosition(_engine, _enumerable.Current);
+                return true;
             }
 
-            return ValueIteratorPosition.Done;
+            nextItem = ValueIteratorPosition.Done;
+            return false;
         }
 
-        public void Return()
+        public void Close(CompletionType completion)
         {
         }
 
@@ -103,7 +107,7 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (_position < _map.GetSize())
                 {
@@ -111,10 +115,12 @@ namespace Jint.Native.Iterator
                     var value = _map._map[key];
 
                     _position++;
-                    return new KeyValueIteratorPosition(_engine, key, value);
+                    nextItem = new KeyValueIteratorPosition(_engine, key, value);
+                    return true;
                 }
 
-                return KeyValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
@@ -136,7 +142,7 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (_end == null)
                 {
@@ -146,10 +152,12 @@ namespace Jint.Native.Iterator
                 if (_position < _end.Value)
                 {
                     _array.TryGetValue(_position, out var value);
-                    return new KeyValueIteratorPosition(_engine, _position++, value);
+                    nextItem = new KeyValueIteratorPosition(_engine, _position++, value);
+                    return true;
                 }
 
-                return KeyValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
@@ -164,16 +172,18 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (_position < _set._set._list.Count)
                 {
                     var value = _set._set[_position];
                     _position++;
-                    return new  ValueIteratorPosition(_engine, value);
+                    nextItem = new  ValueIteratorPosition(_engine, value);
+                    return true;
                 }
 
-                return KeyValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
@@ -188,16 +198,18 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (_position < _set._set._list.Count)
                 {
                     var value = _set._set[_position];
                     _position++;
-                    return new  KeyValueIteratorPosition(_engine, value, value);
+                    nextItem = new  KeyValueIteratorPosition(_engine, value, value);
+                    return true;
                 }
 
-                return KeyValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
@@ -213,17 +225,19 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (!_closed && _position < _values.Count)
                 {
                     var value = _values[_position];
                     _position++;
-                    return new  ValueIteratorPosition(_engine, value);
+                    nextItem = new  ValueIteratorPosition(_engine, value);
+                    return true;
                 }
 
                 _closed = true;
-                return ValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         } 
 
@@ -239,16 +253,18 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 var length = _operations.GetLength();
                 if (!_closed && _position < length)
                 {
-                    return new  ValueIteratorPosition(_engine, _position++);
+                    nextItem = new  ValueIteratorPosition(_engine, _position++);
+                    return true;
                 }
 
                 _closed = true;
-                return ValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
@@ -264,43 +280,74 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 var length = _operations.GetLength();
                 if (!_closed && _position < length)
                 {
                     _operations.TryGetValue(_position++, out var value);
-                    return new ValueIteratorPosition(_engine, value);
+                    nextItem = new ValueIteratorPosition(_engine, value);
+                    return true;
                 }
 
                 _closed = true;
-                return ValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
 
         internal class ObjectWrapper : IIterator
         {
             private readonly ObjectInstance _target;
-            private readonly ICallable _callable;
+            private readonly ICallable _nextMethod;
 
             public ObjectWrapper(ObjectInstance target)
             {
                 _target = target;
-                _callable = target.Get(CommonProperties.Next, target) as ICallable
+                _nextMethod = target.Get(CommonProperties.Next, target) as ICallable
                             ?? ExceptionHelper.ThrowTypeError<ICallable>(target.Engine);
             }
 
-            public ObjectInstance Next()
+            public bool TryIteratorStep(out ObjectInstance result)
+            {
+                result = IteratorNext();
+
+                if (result.TryGetValue(CommonProperties.Done, out var done) && done.AsBoolean())
+                {
+                    return false;
+                }
+
+                return true;
+            }
+
+            private ObjectInstance IteratorNext()
             {
-                return _callable.Call(_target, Arguments.Empty) as ObjectInstance
+                return _nextMethod.Call(_target, Arguments.Empty) as ObjectInstance
                        ?? ExceptionHelper.ThrowTypeError<ObjectInstance>(_target.Engine);
             }
 
-            public void Return()
+            public void Close(CompletionType completion)
             {
-                if (_target.TryGetValue(CommonProperties.Return, out var func))
+                if (!_target.TryGetValue(CommonProperties.Return, out var func))
+                {
+                    return;
+                }
+
+                var innerResult = Undefined;
+                try
+                {
+                    innerResult = ((ICallable) func).Call(_target, Arguments.Empty);
+                }
+                catch
+                {
+                    if (completion != CompletionType.Throw)
+                    {
+                        throw;
+                    }
+                }
+                if (completion != CompletionType.Throw && !innerResult.IsObject())
                 {
-                    ((ICallable) func).Call(_target, Arguments.Empty);
+                    ExceptionHelper.ThrowTypeError(_target.Engine);
                 }
             }
         }
@@ -317,16 +364,18 @@ namespace Jint.Native.Iterator
                 _position = 0;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 var length = _str.Length;
                 if (!_closed && _position < length)
                 {
-                    return new ValueIteratorPosition(_engine, _str[_position++]);
+                    nextItem = new ValueIteratorPosition(_engine, _str[_position++]);
+                    return true;
                 }
 
                 _closed = true;
-                return ValueIteratorPosition.Done;
+                nextItem = KeyValueIteratorPosition.Done;
+                return false;
             }
         }
         
@@ -353,18 +402,20 @@ namespace Jint.Native.Iterator
                 _unicode = unicode;
             }
 
-            public override ObjectInstance Next()
+            public override bool TryIteratorStep(out ObjectInstance nextItem)
             {
                 if (_done)
                 {
-                    return CreateIterResultObject(Undefined, true);
+                    nextItem = CreateIterResultObject(Undefined, true);
+                    return false;
                 }
                 
                 var match  = RegExpPrototype.RegExpExec(_iteratingRegExp, _s);
                 if (match.IsNull())
                 {
                     _done = true;
-                    return CreateIterResultObject(Undefined, true);
+                    nextItem = CreateIterResultObject(Undefined, true);
+                    return false;
                 }
 
                 if (_global)
@@ -382,7 +433,8 @@ namespace Jint.Native.Iterator
                     _done = true;
                 }
 
-                return CreateIterResultObject(match, false);
+                nextItem = CreateIterResultObject(match, false);
+                return false;
             }
         }
     }

Jint/Native/Iterator/IteratorProtocol.cs

@@ -23,16 +23,17 @@ namespace Jint.Native.Iterator
             _argCount = argCount;
         }
 
-        internal void Execute()
+        internal bool Execute()
         {
             var args = _engine._jsValueArrayPool.RentArray(_argCount);
+            var done = false;
             try
             {
                 do
                 {
-                    var item = _iterator.Next();
-                    if (item.TryGetValue(CommonProperties.Done, out var done) && done.AsBoolean())
+                    if (!_iterator.TryIteratorStep(out var item))
                     {
+                        done = true;
                         break;
                     }
 
@@ -46,7 +47,7 @@ namespace Jint.Native.Iterator
             }
             catch
             {
-                ReturnIterator();
+                IteratorClose(CompletionType.Throw);
                 throw;
             }
             finally
@@ -55,11 +56,12 @@ namespace Jint.Native.Iterator
             }
 
             IterationEnd();
+            return done;
         }
 
-        protected void ReturnIterator()
+        protected void IteratorClose(CompletionType completionType)
         {
-            _iterator.Return();
+            _iterator.Close(completionType);
         }
 
         protected virtual bool ShouldContinue => true;
@@ -91,30 +93,26 @@ namespace Jint.Native.Iterator
         {
             if (!(adder is ICallable callable))
             {
-                ExceptionHelper.ThrowTypeError(target.Engine, "set must be callable");
+                ExceptionHelper.ThrowTypeError(target.Engine, "adder must be callable");
                 return;
             }
 
-            var close = false;
             var args = target.Engine._jsValueArrayPool.RentArray(2);
+
+            var skipClose = true;
             try
             {
                 do
                 {
-                    var item = iterable.Next();
-                    if (item.TryGetValue(CommonProperties.Done, out var done) && done.AsBoolean())
+                    if (!iterable.TryIteratorStep(out var nextItem))
                     {
-                        close = true;
-                        break;
+                        return;
                     }
 
-                    if (!item.TryGetValue(CommonProperties.Value, out var currentValue))
-                    {
-                        currentValue = JsValue.Undefined;
-                    }
+                    nextItem.TryGetValue(CommonProperties.Value, out var temp);
 
-                    close = true;
-                    if (!(currentValue is ObjectInstance oi))
+                    skipClose = false;
+                    if (!(temp is ObjectInstance oi))
                     {
                         ExceptionHelper.ThrowTypeError(target.Engine, "iterator's value must be an object");
                         return;
@@ -131,9 +129,9 @@ namespace Jint.Native.Iterator
             }
             catch
             {
-                if (close)
+                if (!skipClose)
                 {
-                    iterable.Return();
+                    iterable.Close(CompletionType.Throw);
                 }
                 throw;
             }
@@ -142,6 +140,5 @@ namespace Jint.Native.Iterator
                 target.Engine._jsValueArrayPool.ReturnArray(args);
             }
         }
-
     }
 }

Jint/Native/Iterator/IteratorPrototype.cs

@@ -51,7 +51,8 @@ namespace Jint.Native.Iterator
                 return ExceptionHelper.ThrowTypeError<JsValue>(_engine);
             }
 
-            return iterator.Next();
+            iterator.TryIteratorStep(out var result);
+            return result;
         }
     }
 }

Jint/Native/Set/SetConstructor.cs

@@ -1,6 +1,5 @@
 using Jint.Collections;
 using Jint.Native.Function;
-using Jint.Native.Iterator;
 using Jint.Native.Object;
 using Jint.Native.Symbol;
 using Jint.Runtime;
@@ -66,46 +65,43 @@ namespace Jint.Native.Set
 
         public ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
         {
-            var instance = new SetInstance(Engine)
+            var set = new SetInstance(Engine)
             {
                 _prototype = PrototypeObject
             };
             if (arguments.Length > 0 && !arguments[0].IsNullOrUndefined())
             {
-                var iterator = arguments.At(0).GetIterator(_engine);
-                var protocol = new SetProtocol(_engine, instance, iterator);
-                protocol.Execute();
-            }
-
-            return instance;
-        }
-
-        private sealed class SetProtocol : IteratorProtocol
-        {
-            private readonly SetInstance _instance;
-            private readonly ICallable _adder;
+                var adderValue = set.Get("add");
+                if (!(adderValue is ICallable adder))
+                {
+                    return ExceptionHelper.ThrowTypeError<ObjectInstance>(_engine, "add must be callable");
+                }
 
-            public SetProtocol(
-                Engine engine,
-                SetInstance instance,
-                IIterator iterator) : base(engine, iterator, 1)
-            {
-                _instance = instance;
-                var setterProperty = instance.GetProperty("add");
+                var iterable = arguments.At(0).GetIterator(_engine);
 
-                if (setterProperty is null
-                    || !setterProperty.TryGetValue(instance, out var setterValue)
-                    || (_adder = setterValue as ICallable) is null)
+                try
+                {
+                    var args = new JsValue[1];
+                    do
+                    {
+                        if (!iterable.TryIteratorStep(out var next))
+                        {
+                            return set;
+                        }
+
+                        next.TryGetValue(CommonProperties.Value, out var nextValue);
+                        args[0] = nextValue;
+                        adder.Call(set, args);
+                    } while (true);
+                }
+                catch
                 {
-                    ExceptionHelper.ThrowTypeError(_engine, "add must be callable");
+                    iterable.Close(CompletionType.Throw);
+                    throw;
                 }
             }
 
-            protected override void ProcessItem(JsValue[] args, JsValue currentValue)
-            {
-                args[0] = ExtractValueFromIteratorInstance(currentValue);
-                _adder.Call(_instance, args);
-            }
+            return set;
         }
     }
 }

Jint/Runtime/Environments/DeclarativeEnvironmentRecord.cs

@@ -464,7 +464,7 @@ namespace Jint.Runtime.Environments
                 if (_index >= 0)
                 {
                     _instance.SetLength((uint) _index);
-                    ReturnIterator();
+                    IteratorClose(CompletionType.Normal);
                 }
             }
         }

Jint/Runtime/Interpreter/Expressions/BindingPatternAssignmentExpression.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using Esprima.Ast;
 using Jint.Native;
@@ -5,65 +6,65 @@ using Jint.Native.Array;
 using Jint.Native.Function;
 using Jint.Native.Iterator;
 using Jint.Runtime.Environments;
+using Jint.Runtime.References;
 
 namespace Jint.Runtime.Interpreter.Expressions
 {
     internal sealed class BindingPatternAssignmentExpression : JintExpression
     {
         private readonly BindingPattern _pattern;
-        private readonly JintExpression _right;
+        private JintExpression _right;
 
         public BindingPatternAssignmentExpression(
             Engine engine, 
             AssignmentExpression expression) : base(engine, expression)
         {
             _pattern = (BindingPattern) expression.Left;
-            _right = Build(engine, expression.Right);
+            _initialized = false;
+        }
+
+        protected override void Initialize()
+        {
+            _right = Build(_engine, ((AssignmentExpression) _expression).Right);
         }
 
         protected override object EvaluateInternal()
         {
             var rightValue = _right.GetValue();
-            ProcessPatterns(_engine, _pattern, rightValue);
-            return JsValue.Undefined;
+            ProcessPatterns(_engine, _pattern, rightValue, true);
+            return rightValue;
         }
 
-        internal static void ProcessPatterns(Engine engine, BindingPattern pattern, JsValue argument)
+        internal static void ProcessPatterns(Engine engine, BindingPattern pattern, JsValue argument, bool checkReference)
         {
             if (pattern is ArrayPattern ap)
             {
-                HandleArrayPattern(engine, ap, argument);
+                HandleArrayPattern(engine, ap, argument, checkReference);
             }
             else if (pattern is ObjectPattern op)
             {
-                HandleObjectPattern(engine, op, argument);
+                HandleObjectPattern(engine, op, argument, checkReference);
             }
         }
-
-        private static void HandleArrayPattern(Engine engine, ArrayPattern pattern, JsValue argument)
+        
+        private static bool ConsumeFromIterator(IIterator it, out JsValue value, out bool done)
         {
-            static bool ConsumeFromIterator(IIterator it, out JsValue value, out bool done)
-            {
-                var item = it.Next();
-                value = JsValue.Undefined;
-                done = false;
-
-                if (item.TryGetValue(CommonProperties.Done, out var d) && d.AsBoolean())
-                {
-                    done = true;
-                    return false;
-                }
-
-                if (!item.TryGetValue(CommonProperties.Value, out value))
-                {
-                    return false;
-                }
+            value = JsValue.Undefined;
+            done = false;
 
-                return true;
+            if (!it.TryIteratorStep(out var d))
+            {
+                done = true;
+                return false;
             }
 
+            d.TryGetValue(CommonProperties.Value, out value);
+            return true;
+        }
+        
+        private static void HandleArrayPattern(Engine engine, ArrayPattern pattern, JsValue argument, bool checkReference)
+        {
             var obj = TypeConverter.ToObject(engine, argument);
-
             ArrayOperations arrayOperations = null;
             IIterator iterator = null;
             if (obj.IsArrayLike)
@@ -79,43 +80,88 @@ namespace Jint.Runtime.Interpreter.Expressions
                 }
             }
 
-            bool iterationEnded = false;
-            for (uint i = 0; i < pattern.Elements.Count; i++)
+            var completionType = CompletionType.Normal;
+            var close = false;
+            var done = false;
+            uint i = 0;
+            try
             {
-                var left = pattern.Elements[(int) i];
-                if (left is Identifier identifier)
+                for (; i < pattern.Elements.Count; i++)
                 {
-                    JsValue value;
-                    if (arrayOperations != null)
+                    var left = pattern.Elements[(int) i];
+
+                    if (left is null)
                     {
-                        arrayOperations.TryGetValue(i, out value);
+                        if (arrayOperations != null)
+                        {
+                            arrayOperations.TryGetValue(i, out _);
+                        }
+                        else
+                        {
+                            if (!ConsumeFromIterator(iterator, out _, out done))
+                            {
+                                break;
+                            }
+                        }
+                        // skip assignment
+                        continue;
                     }
-                    else
+                
+                    if (left is Identifier identifier)
                     {
-                        if (!ConsumeFromIterator(iterator, out value, out iterationEnded))
+                        JsValue value;
+                        if (arrayOperations != null)
                         {
-                            break;
+                            arrayOperations.TryGetValue(i, out value);
+                        }
+                        else
+                        {
+                            if (!ConsumeFromIterator(iterator, out value, out done))
+                            {
+                                break;
+                            }
                         }
+                        AssignToIdentifier(engine, identifier.Name, value, checkReference);
                     }
-                    AssignToIdentifier(engine, identifier.Name, value);
-                }
-                else if (left is BindingPattern bindingPattern)
-                {
-                    JsValue value;
-                    if (arrayOperations != null)
+                    else if (left is MemberExpression me)
                     {
-                        arrayOperations.TryGetValue(i, out value);
+                        close = true;
+                        var reference = GetReferenceFromMember(engine, me);
+                        JsValue value;
+                        if (arrayOperations != null)
+                        {
+                            arrayOperations.TryGetValue(i, out value);
+                        }
+                        else
+                        {
+                            ConsumeFromIterator(iterator, out value, out done);
+                        }
+
+                        AssignToReference(engine, reference, value);
                     }
-                    else
+                    else if (left is BindingPattern bindingPattern)
                     {
-                        value = iterator.Next();
+                        JsValue value;
+                        if (arrayOperations != null)
+                        {
+                            arrayOperations.TryGetValue(i, out value);
+                        }
+                        else
+                        {
+                            iterator.TryIteratorStep(out var temp);
+                            value = temp;
+                        }
+                        ProcessPatterns(engine, bindingPattern, value, checkReference);
                     }
-                    ProcessPatterns(engine, bindingPattern, value);
-                }
-                else if (left is IArrayPatternElement arrayPatternElement)
-                {
-                    if (arrayPatternElement is RestElement restElement)
+                    else if (left is RestElement restElement)
                     {
+                        close = true;
+                        Reference reference = null; 
+                        if (restElement.Argument is MemberExpression memberExpression)
+                        {
+                            reference = GetReferenceFromMember(engine, memberExpression);
+                        }
+                    
                         ArrayInstance array;
                         if (arrayOperations != null)
                         {
@@ -130,20 +176,37 @@ namespace Jint.Runtime.Interpreter.Expressions
                         else
                         {
                             array = engine.Array.ConstructFast(0);
-                            var protocol = new ArrayConstructor.ArrayProtocol(engine, obj, array, iterator, null);
-                            protocol.Execute();
+                            uint index = 0;
+                            done = true;
+                            do
+                            {
+                                if (!iterator.TryIteratorStep(out var item))
+                                {
+                                    done = true;
+                                    break;
+                                }
+
+                                item.TryGetValue(CommonProperties.Value, out var value);
+                                array.SetIndexValue(index++, value, updateLength: false);
+                            } while (true);
+
+                            array.SetLength(index);
                         }
 
                         if (restElement.Argument is Identifier leftIdentifier)
                         {
-                            AssignToIdentifier(engine, leftIdentifier.Name, array);
+                            AssignToIdentifier(engine, leftIdentifier.Name, array, checkReference);
                         }
                         else if (restElement.Argument is BindingPattern bp)
                         {
-                            ProcessPatterns(engine, bp, array);
+                            ProcessPatterns(engine, bp, array, checkReference);
+                        }                    
+                        else
+                        {
+                            AssignToReference(engine, reference,  array);
                         }
                     }
-                    else if (arrayPatternElement is AssignmentPattern assignmentPattern)
+                    else if (left is AssignmentPattern assignmentPattern)
                     {
                         JsValue value;
                         if (arrayOperations != null)
@@ -152,7 +215,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                         }
                         else
                         {
-                            ConsumeFromIterator(iterator, out value, out iterationEnded);
+                            ConsumeFromIterator(iterator, out value, out done);
                         }
 
                         if (value.IsUndefined()
@@ -169,28 +232,39 @@ namespace Jint.Runtime.Interpreter.Expressions
                             {
                                 ((FunctionInstance) value).SetFunctionName(new JsString(leftIdentifier.Name));
                             }
-                            AssignToIdentifier(engine, leftIdentifier.Name, value);
+
+                            AssignToIdentifier(engine, leftIdentifier.Name, value, checkReference);
                         }
                         else if (assignmentPattern.Left is BindingPattern bp)
                         {
-                            ProcessPatterns(engine, bp, value);
+                            ProcessPatterns(engine, bp, value, checkReference);
                         }
                     }
                     else
                     {
-                        ExceptionHelper.ThrowArgumentOutOfRangeException("pattern", "Unable to determine how to handle array pattern element");
+                        ExceptionHelper.ThrowArgumentOutOfRangeException("pattern",
+                            "Unable to determine how to handle array pattern element " + left);
                         break;
                     }
                 }
-            }
 
-            if (!iterationEnded)
+                close = true;
+            }
+            catch
             {
-                iterator?.Return();
+                completionType = CompletionType.Throw;
+                throw;
+            }
+            finally
+            {
+                if (close && !done)
+                {
+                    iterator?.Close(completionType);
+                }
             }
         }
 
-        private static void HandleObjectPattern(Engine engine, ObjectPattern pattern, JsValue argument)
+        private static void HandleObjectPattern(Engine engine, ObjectPattern pattern, JsValue argument, bool checkReference)
         {
             var processedProperties = pattern.Properties.Count > 0 && pattern.Properties[pattern.Properties.Count - 1] is RestElement
                 ? new HashSet<JsValue>()
@@ -203,7 +277,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 {
                     JsValue sourceKey;
                     var identifier = p.Key as Identifier;
-                    if (identifier == null)
+                    if (identifier == null || p.Computed)
                     {
                         var keyExpression = Build(engine, p.Key);
                         sourceKey = TypeConverter.ToPropertyKey(keyExpression.GetValue());
@@ -214,19 +288,18 @@ namespace Jint.Runtime.Interpreter.Expressions
                     }
 
                     processedProperties?.Add(sourceKey.AsStringWithoutTypeCheck());
-                    source.TryGetValue(sourceKey, out var value);
                     if (p.Value is AssignmentPattern assignmentPattern)
                     {
+                        source.TryGetValue(sourceKey, out var value);
                         if (value.IsUndefined() && assignmentPattern.Right is Expression expression)
                         {
                             var jintExpression = Build(engine, expression);
-
                             value = jintExpression.GetValue();
                         }
 
                         if (assignmentPattern.Left is BindingPattern bp)
                         {
-                            ProcessPatterns(engine, bp, value);
+                            ProcessPatterns(engine, bp, value, checkReference);
                             continue;
                         }
 
@@ -237,16 +310,25 @@ namespace Jint.Runtime.Interpreter.Expressions
                             ((FunctionInstance) value).SetFunctionName(target.Name);
                         }
 
-                        AssignToIdentifier(engine, target.Name, value);
+                        AssignToIdentifier(engine, target.Name, value, checkReference);
                     }
                     else if (p.Value is BindingPattern bindingPattern)
                     {
-                        ProcessPatterns(engine, bindingPattern, value);
+                        source.TryGetValue(sourceKey, out var value);
+                        ProcessPatterns(engine, bindingPattern, value, checkReference);
+                    }
+                    else if (p.Value is MemberExpression memberExpression)
+                    {
+                        var reference = GetReferenceFromMember(engine, memberExpression);
+                        source.TryGetValue(sourceKey, out var value);
+                        AssignToReference(engine, reference, value);
                     }
                     else
                     {
-                        var target = p.Value as Identifier ?? identifier;
-                        AssignToIdentifier(engine, target.Name, value);
+                        var identifierReference = p.Value as Identifier;
+                        var target = identifierReference ?? identifier;
+                        source.TryGetValue(sourceKey, out var value);
+                        AssignToIdentifier(engine, target.Name, value, checkReference);
                     }
                 }
                 else
@@ -254,23 +336,49 @@ namespace Jint.Runtime.Interpreter.Expressions
                     var restElement = (RestElement) pattern.Properties[i];
                     if (restElement.Argument is Identifier leftIdentifier)
                     {
-                        var rest = engine.Object.Construct(source.Properties.Count - processedProperties.Count);
+                        var count = Math.Max(0, source.Properties?.Count ?? 0) - processedProperties.Count;
+                        var rest = engine.Object.Construct(count);
                         source.CopyDataProperties(rest, processedProperties);
-                        AssignToIdentifier(engine, leftIdentifier.Name, rest);
+                        AssignToIdentifier(engine, leftIdentifier.Name, rest, checkReference);
                     }
                     else if (restElement.Argument is BindingPattern bp)
                     {
-                        ProcessPatterns(engine, bp, argument);
+                        ProcessPatterns(engine, bp, argument, checkReference);
+                    }
+                    else if (restElement.Argument is MemberExpression memberExpression)
+                    {
+                        var left = GetReferenceFromMember(engine, memberExpression);
+                        var rest = engine.Object.Construct(0);
+                        source.CopyDataProperties(rest, processedProperties);
+                        AssignToReference(engine, left, rest);
+                    }
+                    else
+                    {
+                        ExceptionHelper.ThrowArgumentException("cannot handle parameter type " + restElement.Argument);
                     }
                 }
-
             }
         }
 
+        private static void AssignToReference(Engine engine,  Reference lref,  JsValue rval)
+        {
+            engine.PutValue(lref, rval);
+            engine._referencePool.Return(lref);
+        }
+
+        private static Reference GetReferenceFromMember(Engine engine, MemberExpression memberExpression)
+        {
+            var expression = new JintMemberExpression(engine, memberExpression);
+            var reference = expression.Evaluate() as Reference ?? ExceptionHelper.ThrowReferenceError<Reference>(engine);
+            reference.AssertValid(engine);
+            return reference;
+        }
+
         private static void AssignToIdentifier(
             Engine engine,
             string name,
-            JsValue rval)
+            JsValue rval,
+            bool checkReference)
         {
             var env = engine.ExecutionContext.LexicalEnvironment;
 
@@ -286,6 +394,10 @@ namespace Jint.Runtime.Interpreter.Expressions
             }
             else
             {
+                if (checkReference && strict)
+                {
+                    ExceptionHelper.ThrowReferenceError<Reference>(engine);
+                }
                 env._record.CreateMutableBinding(name, rval);
             }
         }

Jint/Runtime/Interpreter/Expressions/JintAssignmentExpression.cs

@@ -196,11 +196,6 @@ namespace Jint.Runtime.Interpreter.Expressions
 
                 var rval = _right.GetValue();
 
-                if (_right._expression.IsFunctionWithName())
-                {
-                    ((FunctionInstance) rval).SetFunctionName(lref.GetReferencedName());
-                }
-
                 _engine.PutValue(lref, rval);
                 _engine._referencePool.Return(lref);
                 return rval;

Jint/Runtime/Interpreter/Expressions/JintMemberExpression.cs

@@ -81,10 +81,8 @@ namespace Jint.Runtime.Interpreter.Expressions
             }
 
             var property = _determinedProperty ?? _propertyExpression.GetValue();
-
             TypeConverter.CheckObjectCoercible(_engine, baseValue, (MemberExpression) _expression, baseReferenceName);
-
-            return _engine._referencePool.Rent(baseValue, property, isStrictModeCode);
+            return _engine._referencePool.Rent(baseValue,  TypeConverter.ToPropertyKey(property), isStrictModeCode);
         }
     }
 }

Jint/Runtime/Interpreter/Expressions/JintNewExpression.cs

@@ -1,3 +1,4 @@
+using System;
 using Esprima.Ast;
 using Jint.Native;
 
@@ -5,19 +6,25 @@ namespace Jint.Runtime.Interpreter.Expressions
 {
     internal sealed class JintNewExpression : JintExpression
     {
-        private readonly JintExpression _calleeExpression;
-        private JintExpression[] _jintArguments;
+        private JintExpression _calleeExpression;
+        private JintExpression[] _jintArguments = Array.Empty<JintExpression>();
         private bool _hasSpreads;
 
         public JintNewExpression(Engine engine, NewExpression expression) : base(engine, expression)
         {
             _initialized = false;
-            _calleeExpression = Build(engine, expression.Callee);
         }
 
         protected override void Initialize()
         {
             var expression = (NewExpression) _expression;
+            _calleeExpression = Build(_engine, expression.Callee);
+
+            if (expression.Arguments.Count <= 0)
+            {
+                return;
+            }
+
             _jintArguments = new JintExpression[expression.Arguments.Count];
             for (var i = 0; i < _jintArguments.Length; i++)
             {
@@ -29,7 +36,11 @@ namespace Jint.Runtime.Interpreter.Expressions
         protected override object EvaluateInternal()
         {
             JsValue[] arguments;
-            if (_hasSpreads)
+            if (_jintArguments.Length == 0)
+            {
+                arguments = Array.Empty<JsValue>();
+            }
+            else if (_hasSpreads)
             {
                 arguments = BuildArgumentsWithSpreads(_jintArguments);
             }

Jint/Runtime/Interpreter/Statements/JintThrowStatement.cs

@@ -8,11 +8,16 @@ namespace Jint.Runtime.Interpreter.Statements
     /// </summary>
     internal sealed class JintThrowStatement : JintStatement<ThrowStatement>
     {
-        private readonly JintExpression _argument;
+        private JintExpression _argument;
 
         public JintThrowStatement(Engine engine, ThrowStatement statement) : base(engine, statement)
         {
-            _argument = JintExpression.Build(engine, _statement.Argument);
+            _initialized = false;
+        }
+
+        protected override void Initialize()
+        {
+            _argument = JintExpression.Build(_engine, _statement.Argument);
         }
 
         protected override Completion ExecuteInternal()

Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs

@@ -73,7 +73,8 @@ namespace Jint.Runtime.Interpreter.Statements
                         BindingPatternAssignmentExpression.ProcessPatterns(
                             _engine,
                             declaration.LeftPattern,
-                            declaration.Init.GetValue());
+                            declaration.Init.GetValue(),
+                            checkReference: false /* we are variable assignment*/);
                     }
                     else if (declaration.LeftIdentifier == null
                         || JintAssignmentExpression.SimpleAssignmentExpression.AssignToIdentifier(

Jint/Runtime/TypeConverter.cs

@@ -536,7 +536,7 @@ namespace Jint.Runtime
             MemberExpression expression,
             string referencedName)
         {
-            referencedName = referencedName ?? "The value";
+            referencedName ??= "The value";
             var message = $"{referencedName} is {o}";
             throw new JavaScriptException(engine.TypeError, message).SetCallstack(engine, expression.Location);
         }