0bb86794afef217e7f6494266e3e221bf46c903f
[WebKit-https.git] / Source / JavaScriptCore / runtime / ArrayConstructor.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2007-2008, 2011, 2016 Apple Inc. All rights reserved.
4  *  Copyright (C) 2003 Peter Kelly (pmk@post.com)
5  *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
20  *  USA
21  *
22  */
23
24 #include "config.h"
25 #include "ArrayConstructor.h"
26
27 #include "ArrayPrototype.h"
28 #include "ButterflyInlines.h"
29 #include "Error.h"
30 #include "ExceptionHelpers.h"
31 #include "GetterSetter.h"
32 #include "JSArray.h"
33 #include "JSFunction.h"
34 #include "Lookup.h"
35 #include "ProxyObject.h"
36 #include "JSCInlines.h"
37
38 #include "ArrayConstructor.lut.h"
39
40 namespace JSC {
41
42 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(ArrayConstructor);
43
44 const ClassInfo ArrayConstructor::s_info = { "Function", &InternalFunction::s_info, &arrayConstructorTable, CREATE_METHOD_TABLE(ArrayConstructor) };
45
46 /* Source for ArrayConstructor.lut.h
47 @begin arrayConstructorTable
48   of        JSBuiltin                   DontEnum|Function 0
49   from      JSBuiltin                   DontEnum|Function 0
50 @end
51 */
52
53 ArrayConstructor::ArrayConstructor(VM& vm, Structure* structure)
54     : InternalFunction(vm, structure)
55 {
56 }
57
58 void ArrayConstructor::finishCreation(VM& vm, JSGlobalObject* globalObject, ArrayPrototype* arrayPrototype, GetterSetter* speciesSymbol)
59 {
60     Base::finishCreation(vm, arrayPrototype->classInfo(vm)->className);
61     putDirectWithoutTransition(vm, vm.propertyNames->prototype, arrayPrototype, DontEnum | DontDelete | ReadOnly);
62     putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum | DontDelete);
63     putDirectNonIndexAccessor(vm, vm.propertyNames->speciesSymbol, speciesSymbol, Accessor | ReadOnly | DontEnum);
64     JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->isArray, arrayConstructorIsArrayCodeGenerator, DontEnum);
65 }
66
67 // ------------------------------ Functions ---------------------------
68
69 JSValue constructArrayWithSizeQuirk(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, JSValue length, JSValue newTarget)
70 {
71     VM& vm = exec->vm();
72     auto scope = DECLARE_THROW_SCOPE(vm);
73     if (!length.isNumber()) {
74         scope.release();
75         return constructArrayNegativeIndexed(exec, profile, globalObject, &length, 1, newTarget);
76     }
77     
78     uint32_t n = length.toUInt32(exec);
79     if (n != length.toNumber(exec))
80         return throwException(exec, scope, createRangeError(exec, ASCIILiteral("Array size is not a small enough positive integer.")));
81     scope.release();
82     return constructEmptyArray(exec, profile, globalObject, n, newTarget);
83 }
84
85 static inline JSValue constructArrayWithSizeQuirk(ExecState* exec, const ArgList& args, JSValue newTarget)
86 {
87     JSGlobalObject* globalObject = asInternalFunction(exec->jsCallee())->globalObject();
88
89     // a single numeric argument denotes the array size (!)
90     if (args.size() == 1)
91         return constructArrayWithSizeQuirk(exec, nullptr, globalObject, args.at(0), newTarget);
92
93     // otherwise the array is constructed with the arguments in it
94     return constructArray(exec, nullptr, globalObject, args, newTarget);
95 }
96
97 static EncodedJSValue JSC_HOST_CALL constructWithArrayConstructor(ExecState* exec)
98 {
99     ArgList args(exec);
100     return JSValue::encode(constructArrayWithSizeQuirk(exec, args, exec->newTarget()));
101 }
102
103 ConstructType ArrayConstructor::getConstructData(JSCell*, ConstructData& constructData)
104 {
105     constructData.native.function = constructWithArrayConstructor;
106     return ConstructType::Host;
107 }
108
109 static EncodedJSValue JSC_HOST_CALL callArrayConstructor(ExecState* exec)
110 {
111     ArgList args(exec);
112     return JSValue::encode(constructArrayWithSizeQuirk(exec, args, JSValue()));
113 }
114
115 CallType ArrayConstructor::getCallData(JSCell*, CallData& callData)
116 {
117     // equivalent to 'new Array(....)'
118     callData.native.function = callArrayConstructor;
119     return CallType::Host;
120 }
121
122 static ALWAYS_INLINE bool isArraySlowInline(ExecState* exec, ProxyObject* proxy)
123 {
124     VM& vm = exec->vm();
125     auto scope = DECLARE_THROW_SCOPE(vm);
126
127     while (true) {
128         if (proxy->isRevoked()) {
129             throwTypeError(exec, scope, ASCIILiteral("Array.isArray cannot be called on a Proxy that has been revoked"));
130             return false;
131         }
132         JSObject* argument = proxy->target();
133
134         if (argument->type() == ArrayType ||  argument->type() == DerivedArrayType)
135             return true;
136
137         if (argument->type() != ProxyObjectType)
138             return false;
139
140         proxy = jsCast<ProxyObject*>(argument);
141     }
142
143     ASSERT_NOT_REACHED();
144 }
145
146 bool isArraySlow(ExecState* exec, ProxyObject* argument)
147 {
148     return isArraySlowInline(exec, argument);
149 }
150
151 // ES6 7.2.2
152 // https://tc39.github.io/ecma262/#sec-isarray
153 EncodedJSValue JSC_HOST_CALL arrayConstructorPrivateFuncIsArraySlow(ExecState* exec)
154 {
155     ASSERT(jsDynamicCast<ProxyObject*>(exec->vm(), exec->argument(0)));
156     return JSValue::encode(jsBoolean(isArraySlowInline(exec, jsCast<ProxyObject*>(exec->uncheckedArgument(0)))));
157 }
158
159 EncodedJSValue JSC_HOST_CALL arrayConstructorPrivateFuncIsArrayConstructor(ExecState* exec)
160 {
161     VM& vm = exec->vm();
162     return JSValue::encode(jsBoolean(jsDynamicCast<ArrayConstructor*>(vm, exec->uncheckedArgument(0))));
163 }
164
165 } // namespace JSC