Remove some tests from exclude and fix accordingly (#1504)

Jint.Tests.Test262/Test262Harness.settings.json

@@ -36,9 +36,6 @@
     "intl402"
   ],
   "ExcludedFiles": [
-    // Esprima problem, Unexpected token *
-    "language/expressions/object/dstr-async-gen-meth-*",
-
     // Esprima problem for regex, https://github.com/sebastienros/esprima-dotnet/pull/364
     "built-ins/RegExp/S15.10.4.1_A9_T3.js",
 
@@ -101,11 +98,6 @@
     "built-ins/MapIteratorPrototype/next/iteration-mutable.js",
     "built-ins/Set/prototype/forEach/iterates-values-revisits-after-delete-re-add.js",
 
-    // requires toLocaleString changes
-    "built-ins/Array/prototype/toLocaleString/primitive_this_value.js",
-    "built-ins/Array/prototype/toLocaleString/primitive_this_value_getter.js",
-    "built-ins/Object/prototype/toLocaleString/primitive_this_value_getter.js",
-
     // Line feed problems (git, windows, linux)
     "language/expressions/template-literal/tv-line-terminator-sequence.js",
 
@@ -127,12 +119,6 @@
     "built-ins/TypedArrayConstructors/ctors/object-arg/as-generator-iterable-returns.js",
     "language/expressions/object/method-definition/name-prop-name-yield-id.js",
 
-    // not implemented: Creation of new variable environment for the function body (as distinct from that for the function's parameters)
-    "language/expressions/arrow-function/scope-paramsbody-var-open.js",
-    "language/expressions/function/scope-paramsbody-var-open.js",
-    "language/expressions/object/scope-meth-paramsbody-var-open.js",
-    "language/expressions/object/scope-setter-paramsbody-var-open.js",
-
     // generators not implemented
     "built-ins/Object/prototype/toString/proxy-function.js",
     "built-ins/ShadowRealm/prototype/evaluate/wrapped-function-from-return-values-share-no-identity.js",
@@ -358,46 +344,12 @@
     "language/expressions/assignment/target-member-identifier-reference-undefined.js",
     "language/expressions/assignment/target-super-computed-reference-null.js",
     "language/expressions/assignment/target-super-identifier-reference-null.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--1.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--10.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--11.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--12.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--13.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--14.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--15.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--16.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--17.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--18.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--19.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--2.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--20.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--21.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--3.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--4.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--5.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--6.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--7.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--8.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v--9.js",
-    "language/expressions/compound-assignment/compound-assignment-operator-calls-putvalue-lref--v-.js",
     "language/expressions/delete/super-property-null-base.js",
-    "language/expressions/function/dstr/ary-init-iter-get-err-array-prototype.js",
-    "language/expressions/function/dstr/dflt-ary-init-iter-get-err-array-prototype.js",
     "language/expressions/function/eval-var-scope-syntax-err.js",
-    "language/expressions/function/name.js",
-    "language/expressions/function/named-no-strict-reassign-fn-name-in-body-in-arrow.js",
-    "language/expressions/function/named-no-strict-reassign-fn-name-in-body-in-eval.js",
-    "language/expressions/function/named-no-strict-reassign-fn-name-in-body.js",
-    "language/expressions/function/named-strict-error-reassign-fn-name-in-body-in-arrow.js",
-    "language/expressions/function/named-strict-error-reassign-fn-name-in-body-in-eval.js",
-    "language/expressions/function/named-strict-error-reassign-fn-name-in-body.js",
     "language/expressions/function/scope-param-elem-var-close.js",
     "language/expressions/function/scope-param-elem-var-open.js",
     "language/expressions/function/scope-param-rest-elem-var-close.js",
     "language/expressions/function/scope-param-rest-elem-var-open.js",
-    "language/expressions/object/__proto__-duplicate-computed.js",
-    "language/expressions/object/__proto__-fn-name.js",
-    "language/expressions/object/__proto__-value-non-object.js",
     "language/expressions/object/cpn-obj-lit-computed-property-name-from-null.js",
     "language/expressions/object/dstr/meth-ary-init-iter-get-err-array-prototype.js",
     "language/expressions/object/dstr/meth-dflt-ary-init-iter-get-err-array-prototype.js",
@@ -462,10 +414,6 @@
     "language/statements/function/scope-param-elem-var-open.js",
     "language/statements/function/scope-param-rest-elem-var-close.js",
     "language/statements/function/scope-param-rest-elem-var-open.js",
-    "language/statements/variable/12.2.1-10-s.js",
-    "language/statements/variable/12.2.1-17-s.js",
-    "language/statements/variable/12.2.1-21-s.js",
-    "language/statements/variable/12.2.1-6-s.js",
     "language/statements/with/cptn-abrupt-empty.js"
   ]
 }

Jint/Engine.cs

@@ -635,7 +635,7 @@ namespace Jint
             var baseValue = reference.GetBase();
             if (reference.IsUnresolvableReference())
             {
-                if (reference.IsStrictReference())
+                if (reference.IsStrictReference() && reference.GetReferencedName() != CommonProperties.Arguments)
                 {
                     ExceptionHelper.ThrowReferenceError(Realm, reference);
                 }

Jint/Native/Array/ArrayPrototype.cs

@@ -1288,7 +1288,7 @@ namespace Jint.Native.Array
         {
             var array = ArrayOperations.For(_realm, thisObj);
             var len = array.GetLength();
-            const string separator = ",";
+            const string Separator = ",";
             if (len == 0)
             {
                 return JsString.Empty;
@@ -1301,32 +1301,19 @@ namespace Jint.Native.Array
             }
             else
             {
-                var elementObj = TypeConverter.ToObject(_realm, firstElement);
-                var func = elementObj.Get("toLocaleString") as ICallable;
-                if (func is null)
-                {
-                    ExceptionHelper.ThrowTypeError(_realm);
-                }
-
-                r = func.Call(elementObj, Arguments.Empty);
+                r = Invoke(firstElement, "toLocaleString", System.Array.Empty<JsValue>());
             }
 
             for (uint k = 1; k < len; k++)
             {
-                string s = r + separator;
+                var s = r + Separator;
                 if (!array.TryGetValue(k, out var nextElement) || nextElement.IsNull())
                 {
                     r = JsString.Empty;
                 }
                 else
                 {
-                    var elementObj = TypeConverter.ToObject(_realm, nextElement);
-                    var func = elementObj.Get("toLocaleString") as ICallable;
-                    if (func is null)
-                    {
-                        ExceptionHelper.ThrowTypeError(_realm);
-                    }
-                    r = func.Call(elementObj, Arguments.Empty);
+                    r = Invoke(nextElement, "toLocaleString", System.Array.Empty<JsValue>());
                 }
 
                 r = s + r;

Jint/Native/Boolean/BooleanInstance.cs

@@ -15,5 +15,5 @@ internal class BooleanInstance : ObjectInstance, IPrimitiveInstance
 
     JsValue IPrimitiveInstance.PrimitiveValue => BooleanData;
 
-    public JsValue BooleanData { get; }
+    public JsBoolean BooleanData { get; }
 }

Jint/Native/Date/DatePrototype.cs

@@ -831,14 +831,7 @@ namespace Jint.Native.Date
                 return Null;
             }
 
-            var toIso = o.Get("toISOString");
-            var callable = toIso as ICallable;
-            if (callable is null)
-            {
-                ExceptionHelper.ThrowTypeError(_realm);
-            }
-
-            return callable.Call(o, Arguments.Empty);
+            return Invoke(o, "toISOString", Arguments.Empty);
         }
 
         private const int HoursPerDay = 24;

Jint/Native/Object/ObjectInstance.cs

@@ -1495,6 +1495,22 @@ namespace Jint.Native.Object
             return min;
         }
 
+        /// <summary>
+        /// https://tc39.es/ecma262/#sec-invoke
+        /// </summary>
+        internal JsValue Invoke(JsValue v, JsValue p, JsValue[] arguments)
+        {
+            var func = v.GetV(_engine.Realm, p);
+            if (func is not ICallable callable)
+            {
+                ExceptionHelper.ThrowTypeError(_engine.Realm, "Can only invoke functions");
+                return default;
+            }
+
+            return callable.Call(v, arguments);
+        }
+
+
         /// <summary>
         /// https://tc39.es/ecma262/#sec-setintegritylevel
         /// </summary>

Jint/Native/Object/ObjectPrototype.cs

@@ -230,16 +230,12 @@ namespace Jint.Native.Object
             }
         }
 
+        /// <summary>
+        /// https://tc39.es/ecma262/#sec-object.prototype.tolocalestring
+        /// </summary>
         private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
         {
-            var o = TypeConverter.ToObject(_realm, thisObject);
-            var func = o.Get("toString");
-            var callable = func as ICallable;
-            if (callable is null)
-            {
-                ExceptionHelper.ThrowTypeError(_realm, "Can only invoke functions");
-            }
-            return TypeConverter.ToJsString(callable.Call(thisObject, arguments));
+            return Invoke(thisObject, "toString", System.Array.Empty<JsValue>());
         }
 
         /// <summary>

Jint/Runtime/Interpreter/Expressions/JintAssignmentExpression.cs

@@ -403,7 +403,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     left.Identifier,
                     out var environmentRecord))
                 {
-                    if (strict && hasEvalOrArguments)
+                    if (strict && hasEvalOrArguments && left.Identifier.Key != KnownKeys.Eval)
                     {
                         ExceptionHelper.ThrowSyntaxError(engine.Realm, "Invalid assignment target");
                     }

Jint/Runtime/Interpreter/Expressions/JintFunctionExpression.cs

@@ -22,15 +22,16 @@ namespace Jint.Runtime.Interpreter.Expressions
         public override JsValue GetValue(EvaluationContext context)
         {
             ScriptFunctionInstance closure;
+            var functionName = _function.Name ?? "";
             if (!_function.Function.Generator)
             {
                 closure = _function.Function.Async
-                    ? InstantiateAsyncFunctionExpression(context, _function.Name)
-                    : InstantiateOrdinaryFunctionExpression(context, _function.Name);
+                    ? InstantiateAsyncFunctionExpression(context, functionName)
+                    : InstantiateOrdinaryFunctionExpression(context, functionName);
             }
             else
             {
-                closure = InstantiateGeneratorFunctionExpression(context, _function.Name);
+                closure = InstantiateGeneratorFunctionExpression(context, functionName);
             }
 
             return closure;

Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs

@@ -200,19 +200,19 @@ namespace Jint.Runtime.Interpreter.Expressions
                     }
 
                     var propValue = completion.Clone();
-                    if (expr._expression.IsFunctionDefinition())
-                    {
-                        var closure = (FunctionInstance) propValue;
-                        closure.SetFunctionName(propName);
-                    }
-
-                    if (objectProperty._key == "__proto__")
+                    if (objectProperty._key == "__proto__" && !objectProperty._value.Computed && !objectProperty._value.Shorthand)
                     {
                         if (propValue.IsObject() || propValue.IsNull())
                         {
                             obj.SetPrototypeOf(propValue);
-                            continue;
                         }
+                        continue;
+                    }
+
+                    if (expr._expression.IsAnonymousFunctionDefinition())
+                    {
+                        var closure = (FunctionInstance) propValue;
+                        closure.SetFunctionName(propName);
                     }
 
                     var propDesc = new PropertyDescriptor(propValue, PropertyFlag.ConfigurableEnumerableWritable);

Jint/Runtime/Interpreter/Expressions/JintUnaryExpression.cs

@@ -32,6 +32,23 @@ namespace Jint.Runtime.Interpreter.Expressions
                 return new JintConstantExpression(expression, cached);
             }
 
+            if (expression.Operator == UnaryOperator.TypeOf)
+            {
+                if (expression.Argument is Literal l)
+                {
+                    var value = JintLiteralExpression.ConvertToJsValue(l);
+                    if (value is not null)
+                    {
+                        // valid for caching
+                        var evaluatedValue = JintTypeOfExpression.GetTypeOfString(value);
+                        expression.AssociatedData = evaluatedValue;
+                        return new JintConstantExpression(expression, evaluatedValue);
+                    }
+                }
+
+                return new JintTypeOfExpression(expression);
+            }
+
             if (expression.Operator == UnaryOperator.Minus
                 && expression.Argument is Literal literal)
             {
@@ -48,6 +65,76 @@ namespace Jint.Runtime.Interpreter.Expressions
             return new JintUnaryExpression(expression);
         }
 
+        private sealed class JintTypeOfExpression : JintExpression
+        {
+            private readonly JintExpression _argument;
+
+            public JintTypeOfExpression(UnaryExpression expression) : base(expression)
+            {
+                _argument = Build(expression.Argument);
+            }
+
+            public override JsValue GetValue(EvaluationContext context)
+            {
+                // need to notify correct node when taking shortcut
+                context.LastSyntaxElement = _expression;
+                return (JsValue) EvaluateInternal(context);
+            }
+
+            protected override object EvaluateInternal(EvaluationContext context)
+            {
+                var engine = context.Engine;
+                var result = _argument.Evaluate(context);
+                JsValue v;
+
+                if (result is Reference rf)
+                {
+                    if (rf.IsUnresolvableReference())
+                    {
+                        engine._referencePool.Return(rf);
+                        return JsString.UndefinedString;
+                    }
+
+                    v = engine.GetValue(rf, true);
+                }
+                else
+                {
+                    v = (JsValue) result;
+                }
+
+                return GetTypeOfString(v);
+            }
+
+            internal static JsString GetTypeOfString(JsValue v)
+            {
+                if (v.IsUndefined())
+                {
+                    return JsString.UndefinedString;
+                }
+
+                if (v.IsNull())
+                {
+                    return JsString.ObjectString;
+                }
+
+                switch (v.Type)
+                {
+                    case Types.Boolean: return JsString.BooleanString;
+                    case Types.Number: return JsString.NumberString;
+                    case Types.BigInt: return JsString.BigIntString;
+                    case Types.String: return JsString.StringString;
+                    case Types.Symbol: return JsString.SymbolString;
+                }
+
+                if (v.IsCallable)
+                {
+                    return JsString.FunctionString;
+                }
+
+                return JsString.ObjectString;
+            }
+        }
+
         public override JsValue GetValue(EvaluationContext context)
         {
             // need to notify correct node when taking shortcut
@@ -176,52 +263,6 @@ namespace Jint.Runtime.Interpreter.Expressions
                     _argument.GetValue(context);
                     return JsValue.Undefined;
 
-                case UnaryOperator.TypeOf:
-                {
-                    var result = _argument.Evaluate(context);
-                    JsValue v;
-
-                    if (result is Reference rf)
-                    {
-                        if (rf.IsUnresolvableReference())
-                        {
-                            engine._referencePool.Return(rf);
-                            return JsString.UndefinedString;
-                        }
-
-                        v = engine.GetValue(rf, true);
-                    }
-                    else
-                    {
-                        v = (JsValue) result;
-                    }
-
-                    if (v.IsUndefined())
-                    {
-                        return JsString.UndefinedString;
-                    }
-
-                    if (v.IsNull())
-                    {
-                        return JsString.ObjectString;
-                    }
-
-                    switch (v.Type)
-                    {
-                        case Types.Boolean: return JsString.BooleanString;
-                        case Types.Number: return JsString.NumberString;
-                        case Types.BigInt: return JsString.BigIntString;
-                        case Types.String: return JsString.StringString;
-                        case Types.Symbol: return JsString.SymbolString;
-                    }
-
-                    if (v.IsCallable)
-                    {
-                        return JsString.FunctionString;
-                    }
-
-                    return JsString.ObjectString;
-                }
                 default:
                     ExceptionHelper.ThrowArgumentException();
                     return null;

Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs

@@ -68,9 +68,10 @@ internal sealed class JintExportDefaultDeclaration : JintStatement<ExportDefault
             value = _simpleExpression!.GetValue(context);
         }
 
-        if (value is ObjectInstance oi && !oi.HasOwnProperty("name"))
+        if (value is FunctionInstance functionInstance
+            && string.IsNullOrWhiteSpace(functionInstance._nameDescriptor?._value?.ToString()))
         {
-            oi.SetFunctionName("default");
+            functionInstance.SetFunctionName("default");
         }
 
         env.InitializeBinding("*default*", value);