Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / runtime / ExceptionHelpers.cpp
1 /*
2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
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  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "ExceptionHelpers.h"
31
32 #include "CallFrame.h"
33 #include "CatchScope.h"
34 #include "CodeBlock.h"
35 #include "ErrorHandlingScope.h"
36 #include "Exception.h"
37 #include "Interpreter.h"
38 #include "JSCInlines.h"
39 #include "JSGlobalObjectFunctions.h"
40 #include "Nodes.h"
41 #include "RuntimeType.h"
42 #include <wtf/text/StringBuilder.h>
43 #include <wtf/text/StringView.h>
44
45 namespace JSC {
46
47 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(TerminatedExecutionError);
48
49 const ClassInfo TerminatedExecutionError::s_info = { "TerminatedExecutionError", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(TerminatedExecutionError) };
50
51 JSValue TerminatedExecutionError::defaultValue(const JSObject*, ExecState* exec, PreferredPrimitiveType hint)
52 {
53     if (hint == PreferString)
54         return jsNontrivialString(exec, String(ASCIILiteral("JavaScript execution terminated.")));
55     return JSValue(PNaN);
56 }
57
58 JSObject* createTerminatedExecutionException(VM* vm)
59 {
60     return TerminatedExecutionError::create(*vm);
61 }
62
63 bool isTerminatedExecutionException(VM& vm, Exception* exception)
64 {
65     if (!exception->value().isObject())
66         return false;
67
68     return exception->value().inherits(vm, TerminatedExecutionError::info());
69 }
70
71 JSObject* createStackOverflowError(ExecState* exec)
72 {
73     return createStackOverflowError(exec, exec->lexicalGlobalObject());
74 }
75
76 JSObject* createStackOverflowError(ExecState* exec, JSGlobalObject* globalObject)
77 {
78     auto* error = createRangeError(exec, globalObject, ASCIILiteral("Maximum call stack size exceeded."));
79     jsCast<ErrorInstance*>(error)->setStackOverflowError();
80     return error;
81 }
82
83 JSObject* createUndefinedVariableError(ExecState* exec, const Identifier& ident)
84 {
85     if (exec->propertyNames().isPrivateName(ident)) {
86         String message(makeString("Can't find private variable: @", exec->propertyNames().lookUpPublicName(ident).string()));
87         return createReferenceError(exec, message);
88     }
89     String message(makeString("Can't find variable: ", ident.string()));
90     return createReferenceError(exec, message);
91 }
92     
93 JSString* errorDescriptionForValue(ExecState* exec, JSValue v)
94 {
95     if (v.isString())
96         return jsNontrivialString(exec, makeString('"', asString(v)->value(exec), '"'));
97     if (v.isSymbol())
98         return jsNontrivialString(exec, asSymbol(v)->descriptiveString());
99     if (v.isObject()) {
100         CallData callData;
101         JSObject* object = asObject(v);
102         if (object->methodTable()->getCallData(object, callData) != CallType::None)
103             return exec->vm().smallStrings.functionString();
104         return jsString(exec, JSObject::calculatedClassName(object));
105     }
106     return v.toString(exec);
107 }
108     
109 static String defaultApproximateSourceError(const String& originalMessage, const String& sourceText)
110 {
111     return makeString(originalMessage, " (near '...", sourceText, "...')");
112 }
113
114 String defaultSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
115 {
116     if (occurrence == ErrorInstance::FoundApproximateSource)
117         return defaultApproximateSourceError(originalMessage, sourceText);
118
119     ASSERT(occurrence == ErrorInstance::FoundExactSource);
120     return makeString(originalMessage, " (evaluating '", sourceText, "')");
121 }
122
123 static String functionCallBase(const String& sourceText)
124
125     // This function retrieves the 'foo.bar' substring from 'foo.bar(baz)'.
126     // FIXME: This function has simple processing of /* */ style comments.
127     // It doesn't properly handle embedded comments of string literals that contain
128     // parenthesis or comment constructs, e.g. foo.bar("/abc\)*/").
129     // https://bugs.webkit.org/show_bug.cgi?id=146304
130
131     unsigned sourceLength = sourceText.length();
132     unsigned idx = sourceLength - 1;
133     if (sourceLength < 2 || sourceText[idx] != ')') {
134         // For function calls that have many new lines in between their open parenthesis
135         // and their closing parenthesis, the text range passed into the message appender 
136         // will not inlcude the text in between these parentheses, it will just be the desired
137         // text that precedes the parentheses.
138         return String();
139     }
140
141     unsigned parenStack = 1;
142     bool isInMultiLineComment = false;
143     idx -= 1;
144     // Note that we're scanning text right to left instead of the more common left to right, 
145     // so syntax detection is backwards.
146     while (parenStack && idx) {
147         UChar curChar = sourceText[idx];
148         if (isInMultiLineComment) {
149             if (curChar == '*' && sourceText[idx - 1] == '/') {
150                 isInMultiLineComment = false;
151                 --idx;
152             }
153         } else if (curChar == '(')
154             --parenStack;
155         else if (curChar == ')')
156             ++parenStack;
157         else if (curChar == '/' && sourceText[idx - 1] == '*') {
158             isInMultiLineComment = true;
159             --idx;
160         }
161
162         if (idx)
163             --idx;
164     }
165
166     if (parenStack) {
167         // As noted in the FIXME at the top of this function, there are bugs
168         // in the above string processing. This algorithm is mostly best effort
169         // and it works for most JS text in practice. However, if we determine
170         // that the algorithm failed, we should just return the empty value.
171         return String();
172     }
173
174     return sourceText.left(idx + 1);
175 }
176
177 static String notAFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
178 {
179     ASSERT(type != TypeFunction);
180
181     if (occurrence == ErrorInstance::FoundApproximateSource)
182         return defaultApproximateSourceError(originalMessage, sourceText);
183
184     ASSERT(occurrence == ErrorInstance::FoundExactSource);
185     auto notAFunctionIndex = originalMessage.reverseFind("is not a function");
186     RELEASE_ASSERT(notAFunctionIndex != notFound);
187     StringView displayValue;
188     if (originalMessage.is8Bit()) 
189         displayValue = StringView(originalMessage.characters8(), notAFunctionIndex - 1);
190     else
191         displayValue = StringView(originalMessage.characters16(), notAFunctionIndex - 1);
192
193     String base = functionCallBase(sourceText);
194     if (!base)
195         return defaultApproximateSourceError(originalMessage, sourceText);
196     StringBuilder builder;
197     builder.append(base);
198     builder.appendLiteral(" is not a function. (In '");
199     builder.append(sourceText);
200     builder.appendLiteral("', '");
201     builder.append(base);
202     builder.appendLiteral("' is ");
203     if (type == TypeSymbol)
204         builder.appendLiteral("a Symbol");
205     else {
206         if (type == TypeObject)
207             builder.appendLiteral("an instance of ");
208         builder.append(displayValue);
209     }
210     builder.append(')');
211
212     return builder.toString();
213 }
214
215 static String invalidParameterInSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
216 {
217     ASSERT_UNUSED(type, type != TypeObject);
218
219     if (occurrence == ErrorInstance::FoundApproximateSource)
220         return defaultApproximateSourceError(originalMessage, sourceText);
221
222     ASSERT(occurrence == ErrorInstance::FoundExactSource);
223     auto inIndex = sourceText.reverseFind("in");
224     if (inIndex == notFound) {
225         // This should basically never happen, since JS code must use the literal
226         // text "in" for the `in` operation. However, if we fail to find "in"
227         // for any reason, just fail gracefully.
228         return originalMessage;
229     }
230     if (sourceText.find("in") != inIndex)
231         return makeString(originalMessage, " (evaluating '", sourceText, "')");
232
233     static const unsigned inLength = 2;
234     String rightHandSide = sourceText.substring(inIndex + inLength).simplifyWhiteSpace();
235     return makeString(rightHandSide, " is not an Object. (evaluating '", sourceText, "')");
236 }
237
238 inline String invalidParameterInstanceofSourceAppender(const String& content, const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
239 {
240     if (occurrence == ErrorInstance::FoundApproximateSource)
241         return defaultApproximateSourceError(originalMessage, sourceText);
242
243     ASSERT(occurrence == ErrorInstance::FoundExactSource);
244     auto instanceofIndex = sourceText.reverseFind("instanceof");
245     RELEASE_ASSERT(instanceofIndex != notFound);
246     if (sourceText.find("instanceof") != instanceofIndex)
247         return makeString(originalMessage, " (evaluating '", sourceText, "')");
248
249     static const unsigned instanceofLength = 10;
250     String rightHandSide = sourceText.substring(instanceofIndex + instanceofLength).simplifyWhiteSpace();
251     return makeString(rightHandSide, content, ". (evaluating '", sourceText, "')");
252 }
253
254 static String invalidParameterInstanceofNotFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType runtimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
255 {
256     return invalidParameterInstanceofSourceAppender(WTF::makeString(" is not a function"), originalMessage, sourceText, runtimeType, occurrence);
257 }
258
259 static String invalidParameterInstanceofhasInstanceValueNotFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType runtimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
260 {
261     return invalidParameterInstanceofSourceAppender(WTF::makeString("[Symbol.hasInstance] is not a function, undefined, or null"), originalMessage, sourceText, runtimeType, occurrence);
262 }
263
264 JSObject* createError(ExecState* exec, JSValue value, const String& message, ErrorInstance::SourceAppender appender)
265 {
266     VM& vm = exec->vm();
267     auto scope = DECLARE_CATCH_SCOPE(vm);
268
269     String errorMessage = makeString(errorDescriptionForValue(exec, value)->value(exec), ' ', message);
270     scope.assertNoException();
271     JSObject* exception = createTypeError(exec, errorMessage, appender, runtimeTypeForValue(value));
272     ASSERT(exception->isErrorInstance());
273     return exception;
274 }
275
276 JSObject* createInvalidFunctionApplyParameterError(ExecState* exec, JSValue value)
277 {
278     JSObject* exception = createTypeError(exec, makeString("second argument to Function.prototype.apply must be an Array-like object"), defaultSourceAppender, runtimeTypeForValue(value));
279     ASSERT(exception->isErrorInstance());
280     return exception;
281 }
282
283 JSObject* createInvalidInParameterError(ExecState* exec, JSValue value)
284 {
285     return createError(exec, value, makeString("is not an Object."), invalidParameterInSourceAppender);
286 }
287
288 JSObject* createInvalidInstanceofParameterErrorNotFunction(ExecState* exec, JSValue value)
289 {
290     return createError(exec, value, makeString(" is not a function"), invalidParameterInstanceofNotFunctionSourceAppender);
291 }
292
293 JSObject* createInvalidInstanceofParameterErrorHasInstanceValueNotFunction(ExecState* exec, JSValue value)
294 {
295     return createError(exec, value, makeString("[Symbol.hasInstance] is not a function, undefined, or null"), invalidParameterInstanceofhasInstanceValueNotFunctionSourceAppender);
296 }
297
298 JSObject* createNotAConstructorError(ExecState* exec, JSValue value)
299 {
300     return createError(exec, value, ASCIILiteral("is not a constructor"), defaultSourceAppender);
301 }
302
303 JSObject* createNotAFunctionError(ExecState* exec, JSValue value)
304 {
305     return createError(exec, value, ASCIILiteral("is not a function"), notAFunctionSourceAppender);
306 }
307
308 JSObject* createNotAnObjectError(ExecState* exec, JSValue value)
309 {
310     return createError(exec, value, ASCIILiteral("is not an object"), defaultSourceAppender);
311 }
312
313 JSObject* createErrorForInvalidGlobalAssignment(ExecState* exec, const String& propertyName)
314 {
315     return createReferenceError(exec, makeString("Strict mode forbids implicit creation of global property '", propertyName, '\''));
316 }
317
318 JSObject* createTDZError(ExecState* exec)
319 {
320     return createReferenceError(exec, "Cannot access uninitialized variable.");
321 }
322
323 JSObject* throwOutOfMemoryError(ExecState* exec, ThrowScope& scope)
324 {
325     return throwException(exec, scope, createOutOfMemoryError(exec));
326 }
327
328 JSObject* throwStackOverflowError(ExecState* exec, ThrowScope& scope)
329 {
330     VM& vm = exec->vm();
331     ErrorHandlingScope errorScope(vm);
332     return throwException(exec, scope, createStackOverflowError(exec));
333 }
334
335 JSObject* throwTerminatedExecutionException(ExecState* exec, ThrowScope& scope)
336 {
337     VM& vm = exec->vm();
338     ErrorHandlingScope errorScope(vm);
339     return throwException(exec, scope, createTerminatedExecutionException(&vm));
340 }
341
342 } // namespace JSC