sebastienros.jint/Jint/Native/Function/FunctionPrototype.cs

#pragma warning disable CA1859 // Use concrete types when possible for improved performance -- most of prototype methods return JsValue

using Jint.Collections;
using Jint.Native.Array;
using Jint.Native.Object;
using Jint.Native.Symbol;
using Jint.Runtime;
using Jint.Runtime.Descriptors;
using Jint.Runtime.Descriptors.Specialized;
using Jint.Runtime.Interop;

namespace Jint.Native.Function
{
    /// <summary>
    /// https://tc39.es/ecma262/#sec-properties-of-the-function-prototype-object
    /// </summary>
    internal sealed class FunctionPrototype : Function
    {
        internal FunctionPrototype(
            Engine engine,
            Realm realm,
            ObjectPrototype objectPrototype)
            : base(engine, realm, JsString.Empty)
        {
            _prototype = objectPrototype;
            _length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
        }

        protected override void Initialize()
        {
            const PropertyFlag PropertyFlags = PropertyFlag.Configurable | PropertyFlag.Writable;
            const PropertyFlag LengthFlags = PropertyFlag.Configurable;
            var properties = new PropertyDictionary(7, checkExistingKeys: false)
            {
                ["constructor"] = new LazyPropertyDescriptor<FunctionPrototype>(this, static prototype => prototype._realm.Intrinsics.Function, PropertyFlag.NonEnumerable),
                ["toString"] = new LazyPropertyDescriptor<FunctionPrototype>(this, static prototype => new ClrFunction(prototype._engine, "toString", prototype.ToString, 0, LengthFlags), PropertyFlags),
                ["apply"] = new LazyPropertyDescriptor<FunctionPrototype>(this, static prototype => new ClrFunction(prototype._engine, "apply", prototype.Apply, 2, LengthFlags), PropertyFlags),
                ["call"] = new LazyPropertyDescriptor<FunctionPrototype>(this, static prototype => new ClrFunction(prototype._engine, "call", prototype.CallImpl, 1, LengthFlags), PropertyFlags),
                ["bind"] = new LazyPropertyDescriptor<FunctionPrototype>(this, static prototype => new ClrFunction(prototype._engine, "bind", prototype.Bind, 1, LengthFlags), PropertyFlags),
                ["arguments"] = new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(_engine, PropertyFlag.Configurable),
                ["caller"] = new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(_engine, PropertyFlag.Configurable)
            };
            SetProperties(properties);

            var symbols = new SymbolDictionary(1)
            {
                [GlobalSymbolRegistry.HasInstance] = new PropertyDescriptor(new ClrFunction(_engine, "[Symbol.hasInstance]", HasInstance, 1, PropertyFlag.Configurable), PropertyFlag.AllForbidden)
            };
            SetSymbols(symbols);
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance
        /// </summary>
        private static JsValue HasInstance(JsValue thisObject, JsValue[] arguments)
        {
            return thisObject.OrdinaryHasInstance(arguments.At(0));
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-function.prototype.bind
        /// </summary>
        private JsValue Bind(JsValue thisObject, JsValue[] arguments)
        {
            if (thisObject is not (ICallable and ObjectInstance oi))
            {
                ExceptionHelper.ThrowTypeError(_realm, "Bind must be called on a function");
                return default;
            }

            var thisArg = arguments.At(0);
            var f = BoundFunctionCreate(oi, thisArg, arguments.Skip(1));

            JsNumber l;
            var targetHasLength = oi.HasOwnProperty(CommonProperties.Length) == true;
            if (targetHasLength)
            {
                var targetLen = oi.Get(CommonProperties.Length);
                if (targetLen is not JsNumber number)
                {
                    l = JsNumber.PositiveZero;
                }
                else
                {
                    if (number.IsPositiveInfinity())
                    {
                        l = number;
                    }
                    else if (number.IsNegativeInfinity())
                    {
                        l = JsNumber.PositiveZero;
                    }
                    else
                    {
                        var targetLenAsInt = (long) TypeConverter.ToIntegerOrInfinity(targetLen);
                        // first argument is target
                        var argumentsLength = System.Math.Max(0, arguments.Length - 1);
                        l = JsNumber.Create((ulong) System.Math.Max(targetLenAsInt - argumentsLength, 0));
                    }
                }
            }
            else
            {
                l = JsNumber.PositiveZero;
            }

            f.DefinePropertyOrThrow(CommonProperties.Length, new PropertyDescriptor(l, PropertyFlag.Configurable));

            var targetName = oi.Get(CommonProperties.Name);
            if (!targetName.IsString())
            {
                targetName = JsString.Empty;
            }

            f.SetFunctionName(targetName, "bound");

            return f;
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-boundfunctioncreate
        /// </summary>
        private BindFunction BoundFunctionCreate(ObjectInstance targetFunction, JsValue boundThis, JsValue[] boundArgs)
        {
            var proto = targetFunction.GetPrototypeOf();
            var obj = new BindFunction(_engine, _realm, proto, targetFunction, boundThis, boundArgs);
            return obj;
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-function.prototype.tostring
        /// </summary>
        private JsValue ToString(JsValue thisObject, JsValue[] arguments)
        {
            if (thisObject.IsObject() && thisObject.IsCallable)
            {
                return thisObject.ToString();
            }

            ExceptionHelper.ThrowTypeError(_realm, "Function.prototype.toString requires that 'this' be a Function");
            return null;
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-function.prototype.apply
        /// </summary>
        private JsValue Apply(JsValue thisObject, JsValue[] arguments)
        {
            var func = thisObject as ICallable;
            if (func is null)
            {
                ExceptionHelper.ThrowTypeError(_realm);
            }
            var thisArg = arguments.At(0);
            var argArray = arguments.At(1);

            if (argArray.IsNullOrUndefined())
            {
                return func.Call(thisArg, Arguments.Empty);
            }

            var argList = CreateListFromArrayLike(_realm, argArray);

            var result = func.Call(thisArg, argList);

            return result;
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-createlistfromarraylike
        /// </summary>
        internal static JsValue[] CreateListFromArrayLike(Realm realm, JsValue argArray, Types? elementTypes = null)
        {
            var argArrayObj = argArray as ObjectInstance;
            if (argArrayObj is null)
            {
                ExceptionHelper.ThrowTypeError(realm);
            }
            var operations = ArrayOperations.For(argArrayObj, forWrite: false);
            var argList = elementTypes is null ? operations.GetAll() : operations.GetAll(elementTypes.Value);
            return argList;
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-function.prototype.call
        /// </summary>
        private JsValue CallImpl(JsValue thisObject, JsValue[] arguments)
        {
            var func = thisObject as ICallable;
            if (func is null)
            {
                ExceptionHelper.ThrowTypeError(_realm);
            }
            JsValue[] values = System.Array.Empty<JsValue>();
            if (arguments.Length > 1)
            {
                values = new JsValue[arguments.Length - 1];
                System.Array.Copy(arguments, 1, values, 0, arguments.Length - 1);
            }

            var result = func.Call(arguments.At(0), values);

            return result;
        }

        protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
        {
            return Undefined;
        }
    }
}