Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/Error.h

87 lines
2.9 KiB
C
Raw Normal View History

LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
LibJS: Convert Error::create() to NonnullGCPtr
2022-12-13 20:49:50 +00:00
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
*/
LibJS: Add all the Error subclasses This patch adds instance, constructor and prototype classes for: - EvalError - InternalError - RangeError - ReferenceError - SyntaxError - TypeError - URIError Enumerator macros are used to reduce the amount of typing. :^)
2020-04-10 12:42:33 +02:00
#pragma once
LibJS+LibWeb+WebContent: Port JS::PropertyKey to UTF-16 This has quite a lot of fall out. But the majority of it is just type or UDL substitution, where the changes just fall through to other function calls. By changing property key storage to UTF-16, the main affected areas are: * NativeFunction names must now be UTF-16 * Bytecode identifiers must now be UTF-16 * Module/binding names must now be UTF-16
2025-08-02 19:27:29 -04:00
#include <AK/FlyString.h>
LibJS+Everywhere: Convert JS::Error to String This includes an Error::create overload to create an Error from a UTF-8 StringView. If creating a String from that view fails, the factory will return an OOM InternalError instead. VM::throw_completion can also make use of this overload via its perfect forwarding.
2023-02-16 14:09:11 -05:00
#include <AK/String.h>
LibJS+LibWeb: Port interned bytecode strings to UTF-16 This was almost a no-op, except we intern JS exception messages. So the bulk of this patch is porting exception messages to UTF-16.
2025-08-07 19:31:52 -04:00
#include <AK/Utf16String.h>
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
#include <LibJS/Export.h>
LibJS: Convert install_error_cause() to ThrowCompletionOr
2021-10-02 16:03:45 +01:00
#include <LibJS/Runtime/Completion.h>
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
#include <LibJS/Runtime/Object.h>
LibJS: Add a traceback to Error Since we have the traceback we now also generate the stack string on demand instead of immediately on construction.
2022-02-07 14:48:09 +01:00
#include <LibJS/SourceRange.h>
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
namespace JS {
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
struct JS_API TracebackFrame {
LibJS: Use FlyString in PropertyKey instead of DeprecatedFlyString This required dealing with *substantial* fallout.
2025-03-18 18:08:02 -05:00
FlyString function_name;
LibJS: Make Error stack traces lazier Instead of eagerly populating the stack trace with a textual representation of every call frame, just store the raw source code range (code, start offset, end offset). From that, we can generate the full rich backtrace when requested, and save ourselves the trouble otherwise. This makes test-wasm take ~7 seconds on my machine instead of ~60. :^)
2023-05-28 08:28:43 +02:00
[[nodiscard]] SourceRange const& source_range() const;
LibJS: Cache symbolicated stack frames on ExecutionContext Instead of re-symbolicating entire stacks from scratch every time we want a JS VM backtrace, we now use the ExecutionContext object as cache storage via a new CachedSourceRange object. This means that once a stack frame has been symbolicated, we don't have to resymbolicate it again (unless the program counter moves within that stack frame). This drastically reduces time spent in symbolication in some WPT tests.
2024-10-14 07:49:12 +02:00
RefPtr<CachedSourceRange> cached_source_range;
LibJS: Add a traceback to Error Since we have the traceback we now also generate the stack string on demand instead of immediately on construction.
2022-02-07 14:48:09 +01:00
};
LibJS+Embedders: Unify stack trace format for uncaught errors Previously these handlers duplicated code and used formats that were different from the one Error.prototype.stack uses. Now they use the same Error::stack_string function, which accepts a new parameter for compacting stack traces with repeating frames.
2023-10-31 21:55:17 +01:00
enum CompactTraceback {
No,
Yes,
};
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
class JS_API Error : public Object {
LibJS+LibWeb: Add JS::Object::inherits(class_name) To allow implementing the DOM class hierarchy in JS bindings, this patch adds an inherits() function that can be used to ask an Object if it inherits from a specific C++ class (by name). The necessary overrides are baked into each Object subclass by the new JS_OBJECT macro, which works similarly to C_OBJECT in LibCore. Thanks to @Dexesttp for suggesting this approach. :^)
2020-06-21 15:14:02 +02:00
JS_OBJECT(Error, Object);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(Error);
LibJS+LibWeb: Add JS::Object::inherits(class_name) To allow implementing the DOM class hierarchy in JS bindings, this patch adds an inherits() function that can be used to ask an Object if it inherits from a specific C++ class (by name). The necessary overrides are baked into each Object subclass by the new JS_OBJECT macro, which works similarly to C_OBJECT in LibCore. Thanks to @Dexesttp for suggesting this approach. :^)
2020-06-21 15:14:02 +02:00
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
static GC::Ref<Error> create(Realm&);
LibJS+LibWeb: Port interned bytecode strings to UTF-16 This was almost a no-op, except we intern JS exception messages. So the bulk of this patch is porting exception messages to UTF-16.
2025-08-07 19:31:52 -04:00
static GC::Ref<Error> create(Realm&, Utf16String message);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
static GC::Ref<Error> create(Realm&, StringView message);
LibJS: Pass prototype to Error constructors
2020-04-17 19:31:48 +02:00
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-12 00:08:28 +02:00
virtual ~Error() override = default;
LibJS: Move install_error_cause() from Object to Error This is only used by Error and its subclasses, so it doesn't need to be available to all objects.
2021-06-26 19:06:55 +01:00
LibJS+Embedders: Unify stack trace format for uncaught errors Previously these handlers duplicated code and used formats that were different from the one Error.prototype.stack uses. Now they use the same Error::stack_string function, which accepts a new parameter for compacting stack traces with repeating frames.
2023-10-31 21:55:17 +01:00
[[nodiscard]] String stack_string(CompactTraceback compact = CompactTraceback::No) const;
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 17:00:28 +01:00
LibJS: Convert install_error_cause() to ThrowCompletionOr
2021-10-02 16:03:45 +01:00
ThrowCompletionOr<void> install_error_cause(Value options);
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 17:00:28 +01:00
LibJS+LibWeb: Port interned bytecode strings to UTF-16 This was almost a no-op, except we intern JS exception messages. So the bulk of this patch is porting exception messages to UTF-16.
2025-08-07 19:31:52 -04:00
void set_message(Utf16String);
LibJS: Allow assigning an error message after Error object creation This will be used by structured deserialization in LibWeb.
2025-07-17 09:48:16 -04:00
LibJS: Add a traceback to Error Since we have the traceback we now also generate the stack string on demand instead of immediately on construction.
2022-02-07 14:48:09 +01:00
Vector<TracebackFrame, 32> const& traceback() const { return m_traceback; }
LibJS: Hide all the constructors! Now that the GC allocator is able to invoke Cell subclass constructors directly via friendship, we no longer need to keep them public. :^)
2022-08-28 23:51:28 +02:00
protected:
explicit Error(Object& prototype);
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 17:00:28 +01:00
private:
LibJS: Avoid naming conflict between Object's and Error's is_error Object defines an is_error virtual method to be overridden by Error for fast-is. This is the same name as the Error.isError constructor method. Rename the former to avoid conflicts, as GCC 15 just started warning on this.
2025-04-26 08:07:22 -04:00
virtual bool is_error_object() const final { return true; }
LibJS: Add fast_is<T> helpers for all the primitive wrapper objects The JS runtime is full of checks for is<NumberObject> and friends. They were showing up in a Speedometer profile as ~1% spent in dynamic_cast, and this basically chops that down to nothing.
2025-03-25 08:34:06 +00:00
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 17:00:28 +01:00
void populate_stack();
LibJS: Add a traceback to Error Since we have the traceback we now also generate the stack string on demand instead of immediately on construction.
2022-02-07 14:48:09 +01:00
Vector<TracebackFrame, 32> m_traceback;
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
};
LibJS: Add fast_is<T> helpers for all the primitive wrapper objects The JS runtime is full of checks for is<NumberObject> and friends. They were showing up in a Speedometer profile as ~1% spent in dynamic_cast, and this basically chops that down to nothing.
2025-03-25 08:34:06 +00:00
template<>
LibJS: Avoid naming conflict between Object's and Error's is_error Object defines an is_error virtual method to be overridden by Error for fast-is. This is the same name as the Error.isError constructor method. Rename the former to avoid conflicts, as GCC 15 just started warning on this.
2025-04-26 08:07:22 -04:00
inline bool Object::fast_is<Error>() const { return is_error_object(); }
LibJS: Add fast_is<T> helpers for all the primitive wrapper objects The JS runtime is full of checks for is<NumberObject> and friends. They were showing up in a Speedometer profile as ~1% spent in dynamic_cast, and this basically chops that down to nothing.
2025-03-25 08:34:06 +00:00
LibJS: Rename JS_ENUMERATE_{ERROR_SUBCLASSES => NATIVE_ERRORS} The fact that they *are* subclasses is an implementation detail and should not be highlighted. The spec calls these NativeErrors, so let's use that. Also added a comment explaining *why* they inherit from Error - I was about to change that :^)
2021-06-11 17:54:42 +01:00
// NOTE: Making these inherit from Error is not required by the spec but
// our way of implementing the [[ErrorData]] internal slot, which is
// used in Object.prototype.toString().
LibJS: Stop propagating small OOM errors from the Error object
2023-09-06 08:18:01 -04:00
#define DECLARE_NATIVE_ERROR(ClassName, snake_name, PrototypeName, ConstructorName) \
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
class JS_API ClassName final : public Error { \
LibJS: Stop propagating small OOM errors from the Error object
2023-09-06 08:18:01 -04:00
JS_OBJECT(ClassName, Error); \
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(ClassName); \
LibJS: Stop propagating small OOM errors from the Error object
2023-09-06 08:18:01 -04:00
\
public: \
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
static GC::Ref<ClassName> create(Realm&); \
LibJS+LibWeb: Port interned bytecode strings to UTF-16 This was almost a no-op, except we intern JS exception messages. So the bulk of this patch is porting exception messages to UTF-16.
2025-08-07 19:31:52 -04:00
static GC::Ref<ClassName> create(Realm&, Utf16String message); \
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
static GC::Ref<ClassName> create(Realm&, StringView message); \
LibJS: Stop propagating small OOM errors from the Error object
2023-09-06 08:18:01 -04:00
\
explicit ClassName(Object& prototype); \
virtual ~ClassName() override = default; \
LibJS: Add all the Error subclasses This patch adds instance, constructor and prototype classes for: - EvalError - InternalError - RangeError - ReferenceError - SyntaxError - TypeError - URIError Enumerator macros are used to reduce the amount of typing. :^)
2020-04-10 12:42:33 +02:00
};
LibJS: Add six typed arrays (signed and unsigned 8/16/32-bit) This patch adds six of the standard type arrays and tries to share as much code as possible: - Uint8Array - Uint16Array - Uint32Array - Int8Array - Int16Array - Int32Array
2020-12-01 21:05:25 +01:00
#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
LibJS: Rename JS_ENUMERATE_{ERROR_SUBCLASSES => NATIVE_ERRORS} The fact that they *are* subclasses is an implementation detail and should not be highlighted. The spec calls these NativeErrors, so let's use that. Also added a comment explaining *why* they inherit from Error - I was about to change that :^)
2021-06-11 17:54:42 +01:00
DECLARE_NATIVE_ERROR(ClassName, snake_name, PrototypeName, ConstructorName)
JS_ENUMERATE_NATIVE_ERRORS
LibJS: Use enumerator macros for boilerplate code around native types
2020-04-10 14:06:52 +02:00
#undef __JS_ENUMERATE
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04:00
LibJS: Implement basic exception throwing You can now throw exceptions by calling Interpreter::throw_exception(). Anyone who calls ASTNode::execute() needs to check afterwards if the Interpreter now has an exception(), and if so, stop what they're doing and simply return. When catching an exception, we'll first execute the CatchClause node if present. After that, we'll execute the finalizer block if present. This is unlikely to be completely correct, but it's a start! :^)
2020-03-24 14:37:39 +01:00
}
Reference in a new issue Copy permalink