finally blocks should not set the exception stack trace when re-throwing the exception.
[WebKit-https.git] / Source / JavaScriptCore / runtime / ExceptionHelpers.cpp
1 /*
2  * Copyright (C) 2008, 2009 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 "CodeBlock.h"
33 #include "CallFrame.h"
34 #include "ErrorHandlingScope.h"
35 #include "Exception.h"
36 #include "JSGlobalObjectFunctions.h"
37 #include "JSNotAnObject.h"
38 #include "Interpreter.h"
39 #include "Nodes.h"
40 #include "JSCInlines.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, 0, 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(Exception* exception)
64 {
65     return exception->value().inherits(TerminatedExecutionError::info());
66 }
67
68 JSObject* createStackOverflowError(ExecState* exec)
69 {
70     return createRangeError(exec, ASCIILiteral("Maximum call stack size exceeded."));
71 }
72
73 JSObject* createUndefinedVariableError(ExecState* exec, const Identifier& ident)
74 {
75     if (exec->propertyNames().isPrivateName(ident)) {
76         String message(makeString("Can't find private variable: @", exec->propertyNames().getPublicName(ident).string()));
77         return createReferenceError(exec, message);
78     }
79     String message(makeString("Can't find variable: ", ident.string()));
80     return createReferenceError(exec, message);
81 }
82     
83 JSString* errorDescriptionForValue(ExecState* exec, JSValue v)
84 {
85     VM& vm = exec->vm();
86     if (v.isNull())
87         return vm.smallStrings.nullString();
88     if (v.isUndefined())
89         return vm.smallStrings.undefinedString();
90     if (v.isInt32())
91         return jsString(&vm, vm.numericStrings.add(v.asInt32()));
92     if (v.isDouble())
93         return jsString(&vm, vm.numericStrings.add(v.asDouble()));
94     if (v.isTrue())
95         return vm.smallStrings.trueString();
96     if (v.isFalse())
97         return vm.smallStrings.falseString();
98     if (v.isString())
99         return jsNontrivialString(&vm, makeString('"',  asString(v)->value(exec), '"'));
100     if (v.isObject()) {
101         CallData callData;
102         JSObject* object = asObject(v);
103         if (object->methodTable()->getCallData(object, callData) != CallTypeNone)
104             return vm.smallStrings.functionString();
105         return jsString(exec, JSObject::calculatedClassName(object));
106     }
107     
108     // The JSValue should never be empty, so this point in the code should never be reached.
109     ASSERT_NOT_REACHED();
110     return vm.smallStrings.emptyString();
111 }
112     
113 static String defaultApproximateSourceError(const String& originalMessage, const String& sourceText)
114 {
115     return makeString(originalMessage, " (near '...", sourceText, "...')");
116 }
117
118 static String defaultSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
119 {
120     if (occurrence == ErrorInstance::FoundApproximateSource)
121         return defaultApproximateSourceError(originalMessage, sourceText);
122
123     ASSERT(occurrence == ErrorInstance::FoundExactSource);
124     return makeString(originalMessage, " (evaluating '", sourceText, "')");
125 }
126
127 static String functionCallBase(const String& sourceText)
128
129     // This function retrieves the 'foo.bar' substring from 'foo.bar(baz)'.
130     unsigned idx = sourceText.length() - 1;
131     if (sourceText[idx] != ')') {
132         // For function calls that have many new lines in between their open parenthesis
133         // and their closing parenthesis, the text range passed into the message appender 
134         // will not inlcude the text in between these parentheses, it will just be the desired
135         // text that precedes the parentheses.
136         return sourceText;
137     }
138
139     unsigned parenStack = 1;
140     bool isInMultiLineComment = false;
141     idx -= 1;
142     // Note that we're scanning text right to left instead of the more common left to right, 
143     // so syntax detection is backwards.
144     while (parenStack > 0) {
145         UChar curChar = sourceText[idx];
146         if (isInMultiLineComment)  {
147             if (curChar == '*' && sourceText[idx - 1] == '/') {
148                 isInMultiLineComment = false;
149                 idx -= 1;
150             }
151         } else if (curChar == '(')
152             parenStack -= 1;
153         else if (curChar == ')')
154             parenStack += 1;
155         else if (curChar == '/' && sourceText[idx - 1] == '*') {
156             isInMultiLineComment = true;
157             idx -= 1;
158         }
159
160         idx -= 1;
161     }
162
163     return sourceText.left(idx + 1);
164 }
165
166 static String notAFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
167 {
168     ASSERT(type != TypeFunction);
169
170     if (occurrence == ErrorInstance::FoundApproximateSource)
171         return defaultApproximateSourceError(originalMessage, sourceText);
172
173     ASSERT(occurrence == ErrorInstance::FoundExactSource);
174     auto notAFunctionIndex = originalMessage.reverseFind("is not a function");
175     RELEASE_ASSERT(notAFunctionIndex != notFound);
176     StringView displayValue;
177     if (originalMessage.is8Bit()) 
178         displayValue = StringView(originalMessage.characters8(), notAFunctionIndex - 1);
179     else
180         displayValue = StringView(originalMessage.characters16(), notAFunctionIndex - 1);
181
182     String base = functionCallBase(sourceText);
183     StringBuilder builder;
184     builder.append(base);
185     builder.appendLiteral(" is not a function. (In '");
186     builder.append(sourceText);
187     builder.appendLiteral("', '");
188     builder.append(base);
189     builder.appendLiteral("' is ");
190     if (type == TypeObject)
191         builder.appendLiteral("an instance of ");
192     builder.append(displayValue);
193     builder.appendLiteral(")");
194
195     return builder.toString();
196 }
197
198 static String invalidParameterInSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
199 {
200     ASSERT_UNUSED(type, type != TypeObject);
201
202     if (occurrence == ErrorInstance::FoundApproximateSource)
203         return defaultApproximateSourceError(originalMessage, sourceText);
204
205     ASSERT(occurrence == ErrorInstance::FoundExactSource);
206     auto inIndex = sourceText.reverseFind("in");
207     RELEASE_ASSERT(inIndex != notFound);
208     if (sourceText.find("in") != inIndex)
209         return makeString(originalMessage, " (evaluating '", sourceText, "')");
210
211     static const unsigned inLength = 2;
212     String rightHandSide = sourceText.substring(inIndex + inLength).simplifyWhiteSpace();
213     return makeString(rightHandSide, " is not an Object. (evaluating '", sourceText, "')");
214 }
215
216 static String invalidParameterInstanceofSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
217 {
218     if (occurrence == ErrorInstance::FoundApproximateSource)
219         return defaultApproximateSourceError(originalMessage, sourceText);
220
221     ASSERT(occurrence == ErrorInstance::FoundExactSource);
222     auto instanceofIndex = sourceText.reverseFind("instanceof");
223     RELEASE_ASSERT(instanceofIndex != notFound);
224     if (sourceText.find("instanceof") != instanceofIndex)
225         return makeString(originalMessage, " (evaluating '", sourceText, "')");
226
227     static const unsigned instanceofLength = 10;
228     String rightHandSide = sourceText.substring(instanceofIndex + instanceofLength).simplifyWhiteSpace();
229     return makeString(rightHandSide, " is not a function. (evaluating '", sourceText, "')");
230 }
231
232 JSObject* createError(ExecState* exec, JSValue value, const String& message, ErrorInstance::SourceAppender appender)
233 {
234     String errorMessage = makeString(errorDescriptionForValue(exec, value)->value(exec), ' ', message);
235     JSObject* exception = createTypeError(exec, errorMessage, appender, runtimeTypeForValue(value));
236     ASSERT(exception->isErrorInstance());
237     return exception;
238 }
239
240 JSObject* createInvalidFunctionApplyParameterError(ExecState* exec, JSValue value)
241 {
242     JSObject* exception = createTypeError(exec, makeString("second argument to Function.prototype.apply must be an Array-like object"), defaultSourceAppender, runtimeTypeForValue(value));
243     ASSERT(exception->isErrorInstance());
244     return exception;
245 }
246
247 JSObject* createInvalidInParameterError(ExecState* exec, JSValue value)
248 {
249     return createError(exec, value, makeString("is not an Object."), invalidParameterInSourceAppender);
250 }
251
252 JSObject* createInvalidInstanceofParameterError(ExecState* exec, JSValue value)
253 {
254     return createError(exec, value, makeString("is not a function."), invalidParameterInstanceofSourceAppender);
255 }
256
257 JSObject* createNotAConstructorError(ExecState* exec, JSValue value)
258 {
259     return createError(exec, value, ASCIILiteral("is not a constructor"), defaultSourceAppender);
260 }
261
262 JSObject* createNotAFunctionError(ExecState* exec, JSValue value)
263 {
264     return createError(exec, value, ASCIILiteral("is not a function"), notAFunctionSourceAppender);
265 }
266
267 JSObject* createNotAnObjectError(ExecState* exec, JSValue value)
268 {
269     return createError(exec, value, ASCIILiteral("is not an object"), defaultSourceAppender);
270 }
271
272 JSObject* createErrorForInvalidGlobalAssignment(ExecState* exec, const String& propertyName)
273 {
274     return createReferenceError(exec, makeString("Strict mode forbids implicit creation of global property '", propertyName, '\''));
275 }
276
277 JSObject* throwOutOfMemoryError(ExecState* exec)
278 {
279     return exec->vm().throwException(exec, createOutOfMemoryError(exec));
280 }
281
282 JSObject* throwStackOverflowError(ExecState* exec)
283 {
284     VM& vm = exec->vm();
285     ErrorHandlingScope errorScope(vm);
286     return vm.throwException(exec, createStackOverflowError(exec));
287 }
288
289 JSObject* throwTerminatedExecutionException(ExecState* exec)
290 {
291     VM& vm = exec->vm();
292     ErrorHandlingScope errorScope(vm);
293     return vm.throwException(exec, createTerminatedExecutionException(&vm));
294 }
295
296 } // namespace JSC