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