We should support CreateThis in the FTL
[WebKit-https.git] / Source / JavaScriptCore / runtime / IteratorOperations.cpp
1 /*
2  * Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>.
3  * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "IteratorOperations.h"
29
30 #include "CatchScope.h"
31 #include "Error.h"
32 #include "JSCInlines.h"
33 #include "ObjectConstructor.h"
34
35 using namespace WTF;
36
37 namespace JSC {
38
39 JSValue iteratorNext(ExecState* exec, IterationRecord iterationRecord, JSValue argument)
40 {
41     VM& vm = exec->vm();
42     auto scope = DECLARE_THROW_SCOPE(vm);
43
44     JSValue iterator = iterationRecord.iterator;
45     JSValue nextFunction = iterationRecord.nextMethod;
46
47     CallData nextFunctionCallData;
48     CallType nextFunctionCallType = getCallData(vm, nextFunction, nextFunctionCallData);
49     if (nextFunctionCallType == CallType::None)
50         return throwTypeError(exec, scope);
51
52     MarkedArgumentBuffer nextFunctionArguments;
53     if (!argument.isEmpty())
54         nextFunctionArguments.append(argument);
55     ASSERT(!nextFunctionArguments.hasOverflowed());
56     JSValue result = call(exec, nextFunction, nextFunctionCallType, nextFunctionCallData, iterator, nextFunctionArguments);
57     RETURN_IF_EXCEPTION(scope, JSValue());
58
59     if (!result.isObject())
60         return throwTypeError(exec, scope, "Iterator result interface is not an object."_s);
61
62     return result;
63 }
64
65 JSValue iteratorValue(ExecState* exec, JSValue iterResult)
66 {
67     return iterResult.get(exec, exec->vm().propertyNames->value);
68 }
69
70 bool iteratorComplete(ExecState* exec, JSValue iterResult)
71 {
72     JSValue done = iterResult.get(exec, exec->vm().propertyNames->done);
73     return done.toBoolean(exec);
74 }
75
76 JSValue iteratorStep(ExecState* exec, IterationRecord iterationRecord)
77 {
78     VM& vm = exec->vm();
79     auto scope = DECLARE_THROW_SCOPE(vm);
80
81     JSValue result = iteratorNext(exec, iterationRecord);
82     RETURN_IF_EXCEPTION(scope, JSValue());
83     bool done = iteratorComplete(exec, result);
84     RETURN_IF_EXCEPTION(scope, JSValue());
85     if (done)
86         return jsBoolean(false);
87     return result;
88 }
89
90 void iteratorClose(ExecState* exec, IterationRecord iterationRecord)
91 {
92     VM& vm = exec->vm();
93     auto throwScope = DECLARE_THROW_SCOPE(vm);
94     auto catchScope = DECLARE_CATCH_SCOPE(vm);
95
96     Exception* exception = nullptr;
97     if (UNLIKELY(catchScope.exception())) {
98         exception = catchScope.exception();
99         catchScope.clearException();
100     }
101     JSValue returnFunction = iterationRecord.iterator.get(exec, vm.propertyNames->returnKeyword);
102     RETURN_IF_EXCEPTION(throwScope, void());
103
104     if (returnFunction.isUndefined()) {
105         if (exception)
106             throwException(exec, throwScope, exception);
107         return;
108     }
109
110     CallData returnFunctionCallData;
111     CallType returnFunctionCallType = getCallData(vm, returnFunction, returnFunctionCallData);
112     if (returnFunctionCallType == CallType::None) {
113         if (exception)
114             throwException(exec, throwScope, exception);
115         else
116             throwTypeError(exec, throwScope);
117         return;
118     }
119
120     MarkedArgumentBuffer returnFunctionArguments;
121     ASSERT(!returnFunctionArguments.hasOverflowed());
122     JSValue innerResult = call(exec, returnFunction, returnFunctionCallType, returnFunctionCallData, iterationRecord.iterator, returnFunctionArguments);
123
124     if (exception) {
125         throwException(exec, throwScope, exception);
126         return;
127     }
128
129     RETURN_IF_EXCEPTION(throwScope, void());
130
131     if (!innerResult.isObject()) {
132         throwTypeError(exec, throwScope, "Iterator result interface is not an object."_s);
133         return;
134     }
135 }
136
137 static const PropertyOffset valuePropertyOffset = 0;
138 static const PropertyOffset donePropertyOffset = 1;
139
140 Structure* createIteratorResultObjectStructure(VM& vm, JSGlobalObject& globalObject)
141 {
142     Structure* iteratorResultStructure = vm.structureCache.emptyObjectStructureForPrototype(&globalObject, globalObject.objectPrototype(), JSFinalObject::defaultInlineCapacity());
143     PropertyOffset offset;
144     iteratorResultStructure = Structure::addPropertyTransition(vm, iteratorResultStructure, vm.propertyNames->value, 0, offset);
145     RELEASE_ASSERT(offset == valuePropertyOffset);
146     iteratorResultStructure = Structure::addPropertyTransition(vm, iteratorResultStructure, vm.propertyNames->done, 0, offset);
147     RELEASE_ASSERT(offset == donePropertyOffset);
148     return iteratorResultStructure;
149 }
150
151 JSObject* createIteratorResultObject(ExecState* exec, JSValue value, bool done)
152 {
153     VM& vm = exec->vm();
154     JSObject* resultObject = constructEmptyObject(exec, exec->lexicalGlobalObject()->iteratorResultObjectStructure());
155     resultObject->putDirect(vm, valuePropertyOffset, value);
156     resultObject->putDirect(vm, donePropertyOffset, jsBoolean(done));
157     return resultObject;
158 }
159
160 bool hasIteratorMethod(ExecState& state, JSValue value)
161 {
162     auto& vm = state.vm();
163     auto scope = DECLARE_THROW_SCOPE(vm);
164
165     if (!value.isObject())
166         return false;
167
168     JSObject* object = asObject(value);
169     CallData callData;
170     CallType callType;
171     JSValue applyMethod = object->getMethod(&state, callData, callType, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
172     RETURN_IF_EXCEPTION(scope, false);
173
174     return !applyMethod.isUndefined();
175 }
176
177 JSValue iteratorMethod(ExecState& state, JSObject* object)
178 {
179     auto& vm = state.vm();
180     auto scope = DECLARE_THROW_SCOPE(vm);
181
182     CallData callData;
183     CallType callType;
184     JSValue method = object->getMethod(&state, callData, callType, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
185     RETURN_IF_EXCEPTION(scope, jsUndefined());
186
187     return method;
188 }
189
190 IterationRecord iteratorForIterable(ExecState& state, JSObject* object, JSValue iteratorMethod)
191 {
192     VM& vm = state.vm();
193     auto scope = DECLARE_THROW_SCOPE(vm);
194
195     CallData iteratorMethodCallData;
196     CallType iteratorMethodCallType = getCallData(vm, iteratorMethod, iteratorMethodCallData);
197     if (iteratorMethodCallType == CallType::None) {
198         throwTypeError(&state, scope);
199         return { };
200     }
201
202     ArgList iteratorMethodArguments;
203     JSValue iterator = call(&state, iteratorMethod, iteratorMethodCallType, iteratorMethodCallData, object, iteratorMethodArguments);
204     RETURN_IF_EXCEPTION(scope, { });
205
206     if (!iterator.isObject()) {
207         throwTypeError(&state, scope);
208         return { };
209     }
210
211     JSValue nextMethod = iterator.getObject()->get(&state, vm.propertyNames->next);
212     RETURN_IF_EXCEPTION(scope, { });
213
214     return { iterator, nextMethod };
215 }
216
217 IterationRecord iteratorForIterable(ExecState* state, JSValue iterable)
218 {
219     VM& vm = state->vm();
220     auto scope = DECLARE_THROW_SCOPE(vm);
221     
222     JSValue iteratorFunction = iterable.get(state, vm.propertyNames->iteratorSymbol);
223     RETURN_IF_EXCEPTION(scope, { });
224     
225     CallData iteratorFunctionCallData;
226     CallType iteratorFunctionCallType = getCallData(vm, iteratorFunction, iteratorFunctionCallData);
227     if (iteratorFunctionCallType == CallType::None) {
228         throwTypeError(state, scope);
229         return { };
230     }
231
232     ArgList iteratorFunctionArguments;
233     JSValue iterator = call(state, iteratorFunction, iteratorFunctionCallType, iteratorFunctionCallData, iterable, iteratorFunctionArguments);
234     RETURN_IF_EXCEPTION(scope, { });
235
236     if (!iterator.isObject()) {
237         throwTypeError(state, scope);
238         return { };
239     }
240
241     JSValue nextMethod = iterator.getObject()->get(state, vm.propertyNames->next);
242     RETURN_IF_EXCEPTION(scope, { });
243
244     return { iterator, nextMethod };
245 }
246
247 } // namespace JSC