beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 17:10:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Libraries/LibJS/Interpreter.cpp

388 lines
14 KiB
C++
Raw Normal View History

LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
LibJS: Make sure we mark everything reachable from the scope stack This ensures that local variables survive GC.
2020-03-09 20:29:22 +00:00
#include <AK/Badge.h>
LibJS: Move join_args() in Interpreter It can be useful outside of Runtime/ConsoleObject.cpp. join_args() => Interpreter::join_arguments()
2020-05-04 10:34:49 +00:00
#include <AK/StringBuilder.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
#include <LibJS/AST.h>
#include <LibJS/Interpreter.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 13:37:39 +00:00
#include <LibJS/Runtime/Error.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/GlobalObject.h>
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
#include <LibJS/Runtime/LexicalEnvironment.h>
LibJS: Add MarkedValueList and use it for argument passing A MarkedValueList is basically a Vector<JS::Value> that registers with the Heap and makes sure that the stored values don't get GC'd. Before this change, we were unsafely keeping Vector<JS::Value> in some places, which is out-of-reach for the live reference finding logic since Vector puts its elements on the heap by default. We now pass all the JavaScript tests even when running with "js -g", which does a GC on every heap allocation.
2020-04-19 15:24:56 +00:00
#include <LibJS/Runtime/MarkedValueList.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/NativeFunction.h>
#include <LibJS/Runtime/Object.h>
LibJS: Allow "delete someGlobalVariable" This is solved by allowing Identifier nodes to produce a Reference with the global object as base.
2020-04-27 10:37:27 +00:00
#include <LibJS/Runtime/Reference.h>
LibJS: Hoist function declarations This patch adds function declaration hoisting. The mechanism is similar to var hoisting. Hoisted function declarations are to be put before the hoisted var declarations, hence they have to be treated separately.
2020-06-04 12:48:36 +00:00
#include <LibJS/Runtime/ScriptFunction.h>
LibJS: Start implementing object shapes This patch adds JS::Shape, which implements a transition tree for our Object class. Object property keys, prototypes and attributes are now stored in a Shape, and each Object has a Shape. When adding a property to an Object, we make a transition from the old Shape to a new Shape. If we've made the same exact transition in the past (with another Object), we reuse the same transition and both objects may now share a Shape. This will become the foundation of inline caching and other engine optimizations in the future. :^)
2020-04-02 17:32:21 +00:00
#include <LibJS/Runtime/Shape.h>
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-30 06:25:21 +00:00
#include <LibJS/Runtime/SymbolObject.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/Value.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
LibJS: Hide interpreter exception debug output behind a flag
2020-07-03 01:01:09 +00:00
//#define INTERPRETER_DEBUG
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
namespace JS {
Interpreter::Interpreter()
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 18:23:58 +00:00
: m_heap(*this)
LibJS: Start implementing a Console class for the interpreter The goal is to start factoring out core ConsoleObject functionality and to make ConsoleObject only a JS wrapper around Console.
2020-05-01 12:40:43 +00:00
, m_console(*this)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
{
LibJS: Use macros to enumerate well-known symbols Not only is this a much nicer api (can't pass a typo'd string into the get_well_known_symbol function), it is also a bit more performant since there are no hashmap lookups.
2020-07-09 22:34:20 +00:00
#define __JS_ENUMERATE(SymbolName, snake_name) \
m_well_known_symbol_##snake_name = js_symbol(*this, "Symbol." #SymbolName, false);
JS_ENUMERATE_WELL_KNOWN_SYMBOLS
#undef __JS_ENUMERATE
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
Interpreter::~Interpreter()
{
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
Value Interpreter::run(GlobalObject& global_object, const Statement& statement, ArgumentVector arguments, ScopeType scope_type)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
{
LibJS: Assert when exception is not cleared before Interpreter::run() This is to prevent bugs like #3091 (fixed in 9810f8872c21eaf2aefff25347d957cd26f34c2d) in the future; we generally don't want Interpreter::run() to be called if the interpreter still has an exception stored. Sure, it could clear those itself but letting users of the interpreter do it explicitly seems sensible.
2020-08-11 15:45:57 +00:00
ASSERT(!exception());
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
if (statement.is_program()) {
if (m_call_stack.is_empty()) {
LibJS: Rename global_call_fram to global_call_frame Seems to be a typo.
2020-04-20 22:53:28 +00:00
CallFrame global_call_frame;
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
global_call_frame.this_value = &global_object;
LibJS: Rename global_call_fram to global_call_frame Seems to be a typo.
2020-04-20 22:53:28 +00:00
global_call_frame.function_name = "(global execution context)";
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
global_call_frame.environment = heap().allocate<LexicalEnvironment>(global_object, LexicalEnvironment::EnvironmentRecordType::Global);
global_call_frame.environment->bind_this_value(&global_object);
if (exception())
return {};
LibJS: Rename global_call_fram to global_call_frame Seems to be a typo.
2020-04-20 22:53:28 +00:00
m_call_stack.append(move(global_call_frame));
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
}
}
LibJS: Implement "else" parsing We can now handle scripts with if/else in LibJS. Most of the changes are about fixing IfStatement to store the consequent and alternate node as Statements. Interpreter now also runs Statements, rather than running ScopeNodes.
2020-03-23 15:46:41 +00:00
if (!statement.is_scope_node())
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
return statement.execute(*this, global_object);
LibJS: Implement "else" parsing We can now handle scripts with if/else in LibJS. Most of the changes are about fixing IfStatement to store the consequent and alternate node as Statements. Interpreter now also runs Statements, rather than running ScopeNodes.
2020-03-23 15:46:41 +00:00
LibJS: Fix bad cast in Interpreter::run() We were casting to BlockStatement when we should cast to ScopeNode.
2020-04-02 07:53:27 +00:00
auto& block = static_cast<const ScopeNode&>(statement);
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
enter_scope(block, move(arguments), scope_type, global_object);
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
LibJS+js: Support getting last value from "_" variable The interpreter now has an "underscore is last value" flag, which makes Interpreter::get_variable() return the last value if: - The m_underscore_is_last_value flag is enabled - The name of the variable lookup is "_" - The result of that lookup is an empty value That means "_" can still be used as a regular variable and will stop doing its magic once anything is assigned to it. Example REPL session: > 1 1 > _ + _ 2 > _ + _ 4 > _ = "foo" "foo" > 1 1 > _ "foo" > delete _ true > 1 1 > _ 1 >
2020-06-08 11:08:35 +00:00
if (block.children().is_empty())
m_last_value = js_undefined();
LibJS: Implement "else" parsing We can now handle scripts with if/else in LibJS. Most of the changes are about fixing IfStatement to store the consequent and alternate node as Statements. Interpreter now also runs Statements, rather than running ScopeNodes.
2020-03-23 15:46:41 +00:00
for (auto& node : block.children()) {
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
m_last_value = node.execute(*this, global_object);
LibJS: Integrate labels into the Interpreter The interpreter now considers a statement or block's label when considering whether or not to break. All statements can be labelled.
2020-05-28 20:36:59 +00:00
if (should_unwind()) {
LibJS: Do not consider un-labeled Block scopes as breakable
2020-08-28 16:52:22 +00:00
if (!block.label().is_null() && should_unwind_until(ScopeType::Breakable, block.label()))
LibJS: Integrate labels into the Interpreter The interpreter now considers a statement or block's label when considering whether or not to break. All statements can be labelled.
2020-05-28 20:36:59 +00:00
stop_unwind();
LibJS: Actually leave the current function scope on "return" We now unwind until the nearest function-level scope on the scope stack when executing a return statement.
2020-03-23 18:19:03 +00:00
break;
LibJS: Integrate labels into the Interpreter The interpreter now considers a statement or block's label when considering whether or not to break. All statements can be labelled.
2020-05-28 20:36:59 +00:00
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
LibJS: Don't return the "last computed value" from Interpreter::run() Only return whatever a "return" statment told us to return. The last computed value is now available in Interpreter::last_value() instead, where the REPL can pick it up.
2020-04-04 21:45:13 +00:00
bool did_return = m_unwind_until == ScopeType::Function;
LibJS: Actually leave the current function scope on "return" We now unwind until the nearest function-level scope on the scope stack when executing a return statement.
2020-03-23 18:19:03 +00:00
if (m_unwind_until == scope_type)
m_unwind_until = ScopeType::None;
LibJS: Implement "else" parsing We can now handle scripts with if/else in LibJS. Most of the changes are about fixing IfStatement to store the consequent and alternate node as Statements. Interpreter now also runs Statements, rather than running ScopeNodes.
2020-03-23 15:46:41 +00:00
exit_scope(block);
LibJS: Don't return the "last computed value" from Interpreter::run() Only return whatever a "return" statment told us to return. The last computed value is now available in Interpreter::last_value() instead, where the REPL can pick it up.
2020-04-04 21:45:13 +00:00
return did_return ? m_last_value : js_undefined();
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
void Interpreter::enter_scope(const ScopeNode& scope_node, ArgumentVector arguments, ScopeType scope_type, GlobalObject& global_object)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
{
LibJS: Hoist function declarations This patch adds function declaration hoisting. The mechanism is similar to var hoisting. Hoisted function declarations are to be put before the hoisted var declarations, hence they have to be treated separately.
2020-06-04 12:48:36 +00:00
for (auto& declaration : scope_node.functions()) {
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
auto* function = ScriptFunction::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), current_environment());
set_variable(declaration.name(), function, global_object);
LibJS: Hoist function declarations This patch adds function declaration hoisting. The mechanism is similar to var hoisting. Hoisted function declarations are to be put before the hoisted var declarations, hence they have to be treated separately.
2020-06-04 12:48:36 +00:00
}
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
if (scope_type == ScopeType::Function) {
m_scope_stack.append({ scope_type, scope_node, false });
return;
}
LibJS: rename JS::DeclarationType => JS::DeclarationKind Many other parsers call it with this name. Also Type can be confusing in this context since the DeclarationType is not the type (number, string, etc.) of the variables that are being declared by the VariableDeclaration.
2020-04-08 09:59:18 +00:00
HashMap<FlyString, Variable> scope_variables_with_declaration_kind;
LibJS: Use HashMap::ensure_capacity() in enter_scope() Preallocate some space in the scope variable map. This avoids a bunch of incremental rehashing in the common case.
2020-04-13 15:23:42 +00:00
scope_variables_with_declaration_kind.ensure_capacity(16);
LibJS: Hoist variable declarations to the nearest relevant scope "var" declarations are hoisted to the nearest function scope, while "let" and "const" are hoisted to the nearest block scope. This is done by the parser, which keeps two scope stacks, one stack for the current var scope and one for the current let/const scope. When the interpreter enters a scope, we walk all of the declarations and insert them into the variable environment. We don't support the temporal dead zone for let/const yet.
2020-04-13 14:42:54 +00:00
for (auto& declaration : scope_node.variables()) {
for (auto& declarator : declaration.declarations()) {
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
if (scope_node.is_program()) {
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
global_object.put(declarator.id().string(), js_undefined());
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
if (exception())
return;
} else {
LibJS: Hoist variable declarations to the nearest relevant scope "var" declarations are hoisted to the nearest function scope, while "let" and "const" are hoisted to the nearest block scope. This is done by the parser, which keeps two scope stacks, one stack for the current var scope and one for the current let/const scope. When the interpreter enters a scope, we walk all of the declarations and insert them into the variable environment. We don't support the temporal dead zone for let/const yet.
2020-04-13 14:42:54 +00:00
scope_variables_with_declaration_kind.set(declarator.id().string(), { js_undefined(), declaration.declaration_kind() });
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
}
LibJS: Hoist variable declarations to the nearest relevant scope "var" declarations are hoisted to the nearest function scope, while "let" and "const" are hoisted to the nearest block scope. This is done by the parser, which keeps two scope stacks, one stack for the current var scope and one for the current let/const scope. When the interpreter enters a scope, we walk all of the declarations and insert them into the variable environment. We don't support the temporal dead zone for let/const yet.
2020-04-13 14:42:54 +00:00
}
}
LibJS: Add NativeFunction, a callable wrapper around a C++ lambda This can be used to implement arbitrary functionality, callable from JavaScript. To make this work, I had to change the way CallExpression passes arguments to the callee. Instead of a HashMap<String, Value>, we now pass an ordered list of Argument { String name; Value value; }. This patch includes a native "print(argument)" function. :^)
2020-03-12 18:53:31 +00:00
for (auto& argument : arguments) {
LibJS: rename JS::DeclarationType => JS::DeclarationKind Many other parsers call it with this name. Also Type can be confusing in this context since the DeclarationType is not the type (number, string, etc.) of the variables that are being declared by the VariableDeclaration.
2020-04-08 09:59:18 +00:00
scope_variables_with_declaration_kind.set(argument.name, { argument.value, DeclarationKind::Var });
LibJS: Implement const variable declarations This also tightens the means of redeclaration of a variable by proxy, since we now have a way of knowing how a variable was initially declared, we can check if it was declared using `let` or `const` and not tolerate redeclaration like we did previously.
2020-03-12 12:24:34 +00:00
}
LibJS: Hoist variable declarations to the nearest relevant scope "var" declarations are hoisted to the nearest function scope, while "let" and "const" are hoisted to the nearest block scope. This is done by the parser, which keeps two scope stacks, one stack for the current var scope and one for the current let/const scope. When the interpreter enters a scope, we walk all of the declarations and insert them into the variable environment. We don't support the temporal dead zone for let/const yet.
2020-04-13 14:42:54 +00:00
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
bool pushed_lexical_environment = false;
LibJS: Remove unreachable code in Interpreter::enter_scope() Functions are handled and short-circuited at the head of enter_scope().
2020-04-16 08:24:45 +00:00
if (!scope_variables_with_declaration_kind.is_empty()) {
LibJS: Move native objects towards two-pass construction To make sure that everything is set up correctly in objects before we start adding properties to them, we split cell allocation into 3 steps: 1. Allocate a cell of appropriate size from the Heap 2. Call the C++ constructor on the cell 3. Call initialize() on the constructed object The job of initialize() is to define all the initial properties. Doing it in a second pass guarantees that the Object has a valid Shape and can find its own GlobalObject.
2020-06-20 13:40:48 +00:00
auto* block_lexical_environment = heap().allocate<LexicalEnvironment>(global_object, move(scope_variables_with_declaration_kind), current_environment());
LibJS: Remove unreachable code in Interpreter::enter_scope() Functions are handled and short-circuited at the head of enter_scope().
2020-04-16 08:24:45 +00:00
m_call_stack.last().environment = block_lexical_environment;
pushed_lexical_environment = true;
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
}
m_scope_stack.append({ scope_type, scope_node, pushed_lexical_environment });
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
void Interpreter::exit_scope(const ScopeNode& scope_node)
{
LibJS: Actually pop frames off of the scope stack when exiting a scope
2020-03-27 10:34:58 +00:00
while (!m_scope_stack.is_empty()) {
auto popped_scope = m_scope_stack.take_last();
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
if (popped_scope.pushed_environment)
m_call_stack.last().environment = m_call_stack.last().environment->parent();
LibJS: Actually pop frames off of the scope stack when exiting a scope
2020-03-27 10:34:58 +00:00
if (popped_scope.scope_node.ptr() == &scope_node)
break;
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
LibJS: Actually leave the current function scope on "return" We now unwind until the nearest function-level scope on the scope stack when executing a return statement.
2020-03-23 18:19:03 +00:00
// If we unwind all the way, just reset m_unwind_until so that future "return" doesn't break.
if (m_scope_stack.is_empty())
m_unwind_until = ScopeType::None;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
void Interpreter::set_variable(const FlyString& name, Value value, GlobalObject& global_object, bool first_assignment)
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
{
LibJS: Do not assume that a call frame exists in {get,set}_variable
2020-04-19 14:12:41 +00:00
if (m_call_stack.size()) {
for (auto* environment = current_environment(); environment; environment = environment->parent()) {
auto possible_match = environment->get(name);
if (possible_match.has_value()) {
if (!first_assignment && possible_match.value().declaration_kind == DeclarationKind::Const) {
LibJS: Consolidate error messages into ErrorTypes.h Now, exceptions can be thrown with interpreter.throw_exception<T>(ErrorType:TYPE, "format", "args", "here").
2020-06-10 05:48:01 +00:00
throw_exception<TypeError>(ErrorType::InvalidAssignToConst);
LibJS: Do not assume that a call frame exists in {get,set}_variable
2020-04-19 14:12:41 +00:00
return;
}
environment->set(name, { value, possible_match.value().declaration_kind });
LibJS: Throw on assignment of an const variable Was stubbed out as an assert, should be handled with a runtime exception.
2020-04-12 22:50:49 +00:00
return;
}
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
}
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
global_object.put(move(name), move(value));
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
Value Interpreter::get_variable(const FlyString& name, GlobalObject& global_object)
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
{
LibJS: Do not assume that a call frame exists in {get,set}_variable
2020-04-19 14:12:41 +00:00
if (m_call_stack.size()) {
for (auto* environment = current_environment(); environment; environment = environment->parent()) {
auto possible_match = environment->get(name);
if (possible_match.has_value())
return possible_match.value().value;
}
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
}
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
auto value = global_object.get(name);
LibJS+js: Support getting last value from "_" variable The interpreter now has an "underscore is last value" flag, which makes Interpreter::get_variable() return the last value if: - The m_underscore_is_last_value flag is enabled - The name of the variable lookup is "_" - The result of that lookup is an empty value That means "_" can still be used as a regular variable and will stop doing its magic once anything is assigned to it. Example REPL session: > 1 1 > _ + _ 2 > _ + _ 4 > _ = "foo" "foo" > 1 1 > _ "foo" > delete _ true > 1 1 > _ 1 >
2020-06-08 11:08:35 +00:00
if (m_underscore_is_last_value && name == "_" && value.is_empty())
return m_last_value;
return value;
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 20:13:55 +00:00
}
LibJS: Allow "delete someGlobalVariable" This is solved by allowing Identifier nodes to produce a Reference with the global object as base.
2020-04-27 10:37:27 +00:00
Reference Interpreter::get_reference(const FlyString& name)
{
if (m_call_stack.size()) {
for (auto* environment = current_environment(); environment; environment = environment->parent()) {
auto possible_match = environment->get(name);
if (possible_match.has_value())
return { Reference::LocalVariable, name };
}
}
LibJS: Support o.f++ :^) This patch teaches UpdateExpression how to use a Reference. Some other changes were necessary to keep tests working: A Reference can now also refer to a local or global variable. This is not fully aligned with the spec since we don't have a Record concept.
2020-04-28 12:44:48 +00:00
return { Reference::GlobalVariable, name };
LibJS: Allow "delete someGlobalVariable" This is solved by allowing Identifier nodes to produce a Reference with the global object as base.
2020-04-27 10:37:27 +00:00
}
LibJS: Move global symbol map from SymbolObject to Interpreter This allows different instances of the Interpreter to have their own global symbols. Also makes Symbol non-copyable and non-moveable.
2020-07-06 23:57:22 +00:00
Symbol* Interpreter::get_global_symbol(const String& description)
{
auto result = m_global_symbol_map.get(description);
if (result.has_value())
return result.value();
auto new_global_symbol = js_symbol(*this, description, true);
m_global_symbol_map.set(description, new_global_symbol);
return new_global_symbol;
}
LibJS: Rename collect_roots() => gather_roots() Since this is about finding the things we should *not* garabge collect, it seemed wrong to call it "collect_something" :^)
2020-03-15 14:12:34 +00:00
void Interpreter::gather_roots(Badge<Heap>, HashTable<Cell*>& roots)
LibJS: Make sure we mark everything reachable from the scope stack This ensures that local variables survive GC.
2020-03-09 20:29:22 +00:00
{
roots.set(m_global_object);
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 13:37:39 +00:00
roots.set(m_exception);
LibJS: Make sure we mark everything reachable from the scope stack This ensures that local variables survive GC.
2020-03-09 20:29:22 +00:00
LibJS: Don't return the "last computed value" from Interpreter::run() Only return whatever a "return" statment told us to return. The last computed value is now available in Interpreter::last_value() instead, where the REPL can pick it up.
2020-04-04 21:45:13 +00:00
if (m_last_value.is_cell())
roots.set(m_last_value.as_cell());
LibJS: Protect function call "this" and arguments from GC This patch adds a CallFrame stack to Interpreter, which keeps track of the "this" value and all argument values passed in function calls. Interpreter::gather_roots() scans the call stack, making sure that all argument values get marked. :^)
2020-03-17 10:00:09 +00:00
for (auto& call_frame : m_call_stack) {
if (call_frame.this_value.is_cell())
roots.set(call_frame.this_value.as_cell());
for (auto& argument : call_frame.arguments) {
if (argument.is_cell())
roots.set(argument.as_cell());
}
LibJS: Introduce LexicalEnvironment This patch replaces the old variable lookup logic with a new one based on lexical environments. This brings us closer to the way JavaScript is actually specced, and also gives us some basic support for closures. The interpreter's call stack frames now have a pointer to the lexical environment for that frame. Each lexical environment can have a chain of parent environments. Before calling a Function, we first ask it to create_environment(). This gives us a new LexicalEnvironment for that function, which has the function's lexical parent's environment as its parent. This allows inner functions to access variables in their outer function: function foo() { <-- LexicalEnvironment A var x = 1; function() { <-- LexicalEnvironment B (parent: A) console.log(x); } } If we return the result of a function expression from a function, that new function object will keep a reference to its parent environment, which is how we get closures. :^) I'm pretty sure I didn't get everything right here, but it's a pretty good start. This is quite a bit slower than before, but also correcter!
2020-04-15 19:58:22 +00:00
roots.set(call_frame.environment);
LibJS: Interpreter should make sure that the "this" stack gets marked
2020-03-15 14:07:49 +00:00
}
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-30 06:25:21 +00:00
LibJS: Use macros to enumerate well-known symbols Not only is this a much nicer api (can't pass a typo'd string into the get_well_known_symbol function), it is also a bit more performant since there are no hashmap lookups.
2020-07-09 22:34:20 +00:00
#define __JS_ENUMERATE(SymbolName, snake_name) \
roots.set(well_known_symbol_##snake_name());
JS_ENUMERATE_WELL_KNOWN_SYMBOLS
#undef __JS_ENUMERATE
LibJS: Move global symbol map from SymbolObject to Interpreter This allows different instances of the Interpreter to have their own global symbols. Also makes Symbol non-copyable and non-moveable.
2020-07-06 23:57:22 +00:00
for (auto& symbol : m_global_symbol_map)
roots.set(symbol.value);
LibJS: Make sure we mark everything reachable from the scope stack This ensures that local variables survive GC.
2020-03-09 20:29:22 +00:00
}
LibJS: Add a helper for calling JS::Function's with arguments The fact that a `MarkedValueList` had to be created was just annoying, so here's an alternative. This patchset also removes some (now) unneeded MarkedValueList.h includes.
2020-08-25 17:48:32 +00:00
Value Interpreter::call_internal(Function& function, Value this_value, Optional<MarkedValueList> arguments)
LibJS: Add Interpreter::call(Function*, this_value, arguments) This helper function takes care of pushing/popping a call frame so you don't need to worry about it.
2020-03-18 14:20:49 +00:00
{
LibJS: Assert that there's no exception on entry in Interpreter::call()
2020-08-14 15:30:34 +00:00
ASSERT(!exception());
LibJS: Add Interpreter::call(Function*, this_value, arguments) This helper function takes care of pushing/popping a call frame so you don't need to worry about it.
2020-03-18 14:20:49 +00:00
auto& call_frame = push_call_frame();
LibJS: Pass JS::Function around by reference more
2020-04-29 11:43:57 +00:00
call_frame.function_name = function.name();
LibJS: Use the function's bound |this| and bound arguments in Interpreter::call()
2020-05-30 06:07:02 +00:00
call_frame.this_value = function.bound_this().value_or(this_value);
call_frame.arguments = function.bound_arguments();
LibJS: Add MarkedValueList and use it for argument passing A MarkedValueList is basically a Vector<JS::Value> that registers with the Heap and makes sure that the stored values don't get GC'd. Before this change, we were unsafely keeping Vector<JS::Value> in some places, which is out-of-reach for the live reference finding logic since Vector puts its elements on the heap by default. We now pass all the JavaScript tests even when running with "js -g", which does a GC on every heap allocation.
2020-04-19 15:24:56 +00:00
if (arguments.has_value())
LibJS: Use the function's bound |this| and bound arguments in Interpreter::call()
2020-05-30 06:07:02 +00:00
call_frame.arguments.append(arguments.value().values());
LibJS: Pass JS::Function around by reference more
2020-04-29 11:43:57 +00:00
call_frame.environment = function.create_environment();
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
ASSERT(call_frame.environment->this_binding_status() == LexicalEnvironment::ThisBindingStatus::Uninitialized);
call_frame.environment->bind_this_value(call_frame.this_value);
LibJS: Pass JS::Function around by reference more
2020-04-29 11:43:57 +00:00
auto result = function.call(*this);
LibJS: Add Interpreter::call(Function*, this_value, arguments) This helper function takes care of pushing/popping a call frame so you don't need to worry about it.
2020-03-18 14:20:49 +00:00
pop_call_frame();
return result;
}
LibJS: Make Interpreter::construct() take a GlobalObject&
2020-06-20 15:53:33 +00:00
Value Interpreter::construct(Function& function, Function& new_target, Optional<MarkedValueList> arguments, GlobalObject& global_object)
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
{
auto& call_frame = push_call_frame();
call_frame.function_name = function.name();
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
call_frame.arguments = function.bound_arguments();
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
if (arguments.has_value())
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
call_frame.arguments.append(arguments.value().values());
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
call_frame.environment = function.create_environment();
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
current_environment()->set_new_target(&new_target);
Object* new_object = nullptr;
if (function.constructor_kind() == Function::ConstructorKind::Base) {
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway.
2020-07-22 15:50:18 +00:00
new_object = Object::create_empty(global_object);
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
current_environment()->bind_this_value(new_object);
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
if (exception())
return {};
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
auto prototype = new_target.get("prototype");
if (exception())
return {};
if (prototype.is_object()) {
new_object->set_prototype(&prototype.as_object());
if (exception())
return {};
}
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
}
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
// If we are a Derived constructor, |this| has not been constructed before super is called.
Value this_value = function.constructor_kind() == Function::ConstructorKind::Base ? new_object : Value {};
call_frame.this_value = this_value;
LibJS: Explicitly pass a "Function& new_target" to Function::construct This allows the proxy handler to pass the proper new.target to construct handlers.
2020-06-25 22:30:58 +00:00
auto result = function.construct(*this, new_target);
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
this_value = current_environment()->get_this_binding();
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
pop_call_frame();
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
// If we are constructing an instance of a derived class,
// set the prototype on objects created by constructors that return an object (i.e. NativeFunction subclasses).
if (function.constructor_kind() == Function::ConstructorKind::Base && new_target.constructor_kind() == Function::ConstructorKind::Derived && result.is_object()) {
current_environment()->replace_this_binding(result);
auto prototype = new_target.get("prototype");
if (exception())
return {};
if (prototype.is_object()) {
result.as_object().set_prototype(&prototype.as_object());
if (exception())
return {};
}
return result;
}
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
if (exception())
return {};
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
if (result.is_object())
return result;
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
return this_value;
LibJS: Implement most of the Reflect object
2020-05-01 10:06:27 +00:00
}
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
void Interpreter::throw_exception(Exception* exception)
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 13:37:39 +00:00
{
LibJS: Hide interpreter exception debug output behind a flag
2020-07-03 01:01:09 +00:00
#ifdef INTERPRETER_DEBUG
LibJS: Log when we throw a JavaScript Error This makes debugging a lot easier since we actually learn that an Error got thrown.
2020-04-04 20:14:03 +00:00
if (exception->value().is_object() && exception->value().as_object().is_error()) {
auto& error = static_cast<Error&>(exception->value().as_object());
dbg() << "Throwing JavaScript Error: " << error.name() << ", " << error.message();
LibJS: Dump a JavaScript backtrace when throwing exceptions
2020-04-16 18:23:03 +00:00
for (ssize_t i = m_call_stack.size() - 1; i >= 0; --i) {
auto function_name = m_call_stack[i].function_name;
if (function_name.is_empty())
function_name = "<anonymous>";
dbg() << " " << function_name;
}
LibJS: Log when we throw a JavaScript Error This makes debugging a lot easier since we actually learn that an Error got thrown.
2020-04-04 20:14:03 +00:00
}
LibJS: Only log exception throw information on Serenity This is a bit annoying when running the js REPL as part of the Lagom build, as it prints the error twice to the same terminal - once from dbg() and then from printf(). Long term this should probably be removed completely and each program take care itself of printing stacktraces to an appropriate location.
2020-05-26 11:52:20 +00:00
#endif
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 13:37:39 +00:00
m_exception = exception;
unwind(ScopeType::Try);
}
LibJS: Add "constructor" property to constructor prototypes
2020-04-08 09:05:38 +00:00
GlobalObject& Interpreter::global_object()
{
return static_cast<GlobalObject&>(*m_global_object);
}
const GlobalObject& Interpreter::global_object() const
{
return static_cast<const GlobalObject&>(*m_global_object);
}
LibJS: Add some helpers and use them to re-implement Console functions Also add const overloads for some getters. Also const-qualify Interpreter::join_arguments().
2020-05-04 12:18:15 +00:00
String Interpreter::join_arguments() const
LibJS: Move join_args() in Interpreter It can be useful outside of Runtime/ConsoleObject.cpp. join_args() => Interpreter::join_arguments()
2020-05-04 10:34:49 +00:00
{
StringBuilder joined_arguments;
for (size_t i = 0; i < argument_count(); ++i) {
LibJS: Add side-effect-free version of Value::to_string() There are now two API's on Value: - Value::to_string(Interpreter&) -- may throw. - Value::to_string_without_side_effects() -- will never throw. These are some pretty big sweeping changes, so it's possible that I did some part the wrong way. We'll work it out as we go. :^) Fixes #2123.
2020-05-15 11:39:24 +00:00
joined_arguments.append(argument(i).to_string_without_side_effects().characters());
LibJS: Move join_args() in Interpreter It can be useful outside of Runtime/ConsoleObject.cpp. join_args() => Interpreter::join_arguments()
2020-05-04 10:34:49 +00:00
if (i != argument_count() - 1)
joined_arguments.append(' ');
}
return joined_arguments.build();
}
LibJS: Initial class implementation; allow super expressions in object literal methods; add EnvrionmentRecord fields and methods to LexicalEnvironment Adding EnvrionmentRecord's fields and methods lets us throw an exception when |this| is not initialized, which occurs when the super constructor in a derived class has not yet been called, or when |this| has already been initialized (the super constructor was already called).
2020-06-08 18:31:21 +00:00
Value Interpreter::resolve_this_binding() const
{
return get_this_environment()->get_this_binding();
}
const LexicalEnvironment* Interpreter::get_this_environment() const
{
// We will always return because the Global environment will always be reached, which has a |this| binding.
for (const LexicalEnvironment* environment = current_environment(); environment; environment = environment->parent()) {
if (environment->has_this_binding())
return environment;
}
ASSERT_NOT_REACHED();
}
Value Interpreter::get_new_target() const
{
return get_this_environment()->new_target();
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
}
Reference in a new issue Copy permalink