diff options
| -rw-r--r-- | Libraries/LibJS/AST.cpp | 4 | ||||
| -rw-r--r-- | Libraries/LibJS/AST.h | 99 | ||||
| -rw-r--r-- | Libraries/LibJS/Interpreter.cpp | 2 | ||||
| -rw-r--r-- | Libraries/LibJS/Interpreter.h | 2 | ||||
| -rw-r--r-- | Libraries/LibJS/Parser.cpp | 130 | ||||
| -rw-r--r-- | Libraries/LibJS/Parser.h | 28 | ||||
| -rw-r--r-- | Libraries/LibJS/Runtime/ScriptFunction.cpp | 1 | ||||
| -rw-r--r-- | Libraries/LibJS/Runtime/ScriptFunction.h | 2 |
8 files changed, 138 insertions, 130 deletions
diff --git a/Libraries/LibJS/AST.cpp b/Libraries/LibJS/AST.cpp index a815a6715a..00dcd1ccb3 100644 --- a/Libraries/LibJS/AST.cpp +++ b/Libraries/LibJS/AST.cpp @@ -100,10 +100,10 @@ Value WhileStatement::execute(Interpreter& interpreter) const Value ForStatement::execute(Interpreter& interpreter) const { - OwnPtr<BlockStatement> wrapper; + RefPtr<BlockStatement> wrapper; if (m_init->is_variable_declaration() && static_cast<const VariableDeclaration*>(m_init.ptr())->declaration_type() != DeclarationType::Var) { - wrapper = make<BlockStatement>(); + wrapper = create_ast_node<BlockStatement>(); interpreter.enter_scope(*wrapper, {}, ScopeType::Block); } diff --git a/Libraries/LibJS/AST.h b/Libraries/LibJS/AST.h index b71ed57732..404e376d30 100644 --- a/Libraries/LibJS/AST.h +++ b/Libraries/LibJS/AST.h @@ -26,8 +26,8 @@ #pragma once -#include <AK/NonnullOwnPtrVector.h> -#include <AK/OwnPtr.h> +#include <AK/NonnullRefPtrVector.h> +#include <AK/RefPtr.h> #include <AK/String.h> #include <AK/Vector.h> #include <LibJS/Forward.h> @@ -35,7 +35,14 @@ namespace JS { -class ASTNode { +template<class T, class... Args> +static inline NonnullRefPtr<T> +create_ast_node(Args&&... args) +{ + return adopt(*new T(forward<Args>(args)...)); +} + +class ASTNode : public RefCounted<ASTNode> { public: virtual ~ASTNode() {} virtual const char* class_name() const = 0; @@ -62,7 +69,7 @@ public: class ExpressionStatement final : public Statement { public: - ExpressionStatement(NonnullOwnPtr<Expression> expression) + ExpressionStatement(NonnullRefPtr<Expression> expression) : m_expression(move(expression)) { } @@ -72,7 +79,7 @@ public: virtual void dump(int indent) const override; private: - NonnullOwnPtr<Expression> m_expression; + NonnullRefPtr<Expression> m_expression; }; class ScopeNode : public Statement { @@ -84,12 +91,12 @@ public: m_children.append(move(child)); return static_cast<T&>(m_children.last()); } - void append(NonnullOwnPtr<Statement> child) + void append(NonnullRefPtr<Statement> child) { m_children.append(move(child)); } - const NonnullOwnPtrVector<Statement>& children() const { return m_children; } + const NonnullRefPtrVector<Statement>& children() const { return m_children; } virtual Value execute(Interpreter&) const override; virtual void dump(int indent) const override; @@ -97,7 +104,7 @@ protected: ScopeNode() {} private: - NonnullOwnPtrVector<Statement> m_children; + NonnullRefPtrVector<Statement> m_children; }; class Program : public ScopeNode { @@ -118,7 +125,7 @@ private: class FunctionDeclaration : public Statement { public: - FunctionDeclaration(String name, NonnullOwnPtr<ScopeNode> body, Vector<String> parameters = {}) + FunctionDeclaration(String name, NonnullRefPtr<ScopeNode> body, Vector<String> parameters = {}) : m_name(move(name)) , m_body(move(body)) , m_parameters(move(parameters)) @@ -136,7 +143,7 @@ private: virtual const char* class_name() const override { return "FunctionDeclaration"; } String m_name; - NonnullOwnPtr<ScopeNode> m_body; + NonnullRefPtr<ScopeNode> m_body; const Vector<String> m_parameters; }; @@ -153,7 +160,7 @@ public: class ReturnStatement : public Statement { public: - explicit ReturnStatement(OwnPtr<Expression> argument) + explicit ReturnStatement(RefPtr<Expression> argument) : m_argument(move(argument)) { } @@ -166,12 +173,12 @@ public: private: virtual const char* class_name() const override { return "ReturnStatement"; } - OwnPtr<Expression> m_argument; + RefPtr<Expression> m_argument; }; class IfStatement : public Statement { public: - IfStatement(NonnullOwnPtr<Expression> predicate, NonnullOwnPtr<ScopeNode> consequent, NonnullOwnPtr<ScopeNode> alternate) + IfStatement(NonnullRefPtr<Expression> predicate, NonnullRefPtr<ScopeNode> consequent, NonnullRefPtr<ScopeNode> alternate) : m_predicate(move(predicate)) , m_consequent(move(consequent)) , m_alternate(move(alternate)) @@ -188,14 +195,14 @@ public: private: virtual const char* class_name() const override { return "IfStatement"; } - NonnullOwnPtr<Expression> m_predicate; - NonnullOwnPtr<ScopeNode> m_consequent; - NonnullOwnPtr<ScopeNode> m_alternate; + NonnullRefPtr<Expression> m_predicate; + NonnullRefPtr<ScopeNode> m_consequent; + NonnullRefPtr<ScopeNode> m_alternate; }; class WhileStatement : public Statement { public: - WhileStatement(NonnullOwnPtr<Expression> predicate, NonnullOwnPtr<ScopeNode> body) + WhileStatement(NonnullRefPtr<Expression> predicate, NonnullRefPtr<ScopeNode> body) : m_predicate(move(predicate)) , m_body(move(body)) { @@ -210,13 +217,13 @@ public: private: virtual const char* class_name() const override { return "WhileStatement"; } - NonnullOwnPtr<Expression> m_predicate; - NonnullOwnPtr<ScopeNode> m_body; + NonnullRefPtr<Expression> m_predicate; + NonnullRefPtr<ScopeNode> m_body; }; class ForStatement : public Statement { public: - ForStatement(OwnPtr<Statement> init, OwnPtr<Expression> test, OwnPtr<Expression> update, NonnullOwnPtr<ScopeNode> body) + ForStatement(RefPtr<Statement> init, RefPtr<Expression> test, RefPtr<Expression> update, NonnullRefPtr<ScopeNode> body) : m_init(move(init)) , m_test(move(test)) , m_update(move(update)) @@ -235,10 +242,10 @@ public: private: virtual const char* class_name() const override { return "ForStatement"; } - OwnPtr<Statement> m_init; - OwnPtr<Expression> m_test; - OwnPtr<Expression> m_update; - NonnullOwnPtr<ScopeNode> m_body; + RefPtr<Statement> m_init; + RefPtr<Expression> m_test; + RefPtr<Expression> m_update; + NonnullRefPtr<ScopeNode> m_body; }; enum class BinaryOp { @@ -263,7 +270,7 @@ enum class BinaryOp { class BinaryExpression : public Expression { public: - BinaryExpression(BinaryOp op, NonnullOwnPtr<Expression> lhs, NonnullOwnPtr<Expression> rhs) + BinaryExpression(BinaryOp op, NonnullRefPtr<Expression> lhs, NonnullRefPtr<Expression> rhs) : m_op(op) , m_lhs(move(lhs)) , m_rhs(move(rhs)) @@ -277,8 +284,8 @@ private: virtual const char* class_name() const override { return "BinaryExpression"; } BinaryOp m_op; - NonnullOwnPtr<Expression> m_lhs; - NonnullOwnPtr<Expression> m_rhs; + NonnullRefPtr<Expression> m_lhs; + NonnullRefPtr<Expression> m_rhs; }; enum class LogicalOp { @@ -288,7 +295,7 @@ enum class LogicalOp { class LogicalExpression : public Expression { public: - LogicalExpression(LogicalOp op, NonnullOwnPtr<Expression> lhs, NonnullOwnPtr<Expression> rhs) + LogicalExpression(LogicalOp op, NonnullRefPtr<Expression> lhs, NonnullRefPtr<Expression> rhs) : m_op(op) , m_lhs(move(lhs)) , m_rhs(move(rhs)) @@ -302,8 +309,8 @@ private: virtual const char* class_name() const override { return "LogicalExpression"; } LogicalOp m_op; - NonnullOwnPtr<Expression> m_lhs; - NonnullOwnPtr<Expression> m_rhs; + NonnullRefPtr<Expression> m_lhs; + NonnullRefPtr<Expression> m_rhs; }; enum class UnaryOp { @@ -314,7 +321,7 @@ enum class UnaryOp { class UnaryExpression : public Expression { public: - UnaryExpression(UnaryOp op, NonnullOwnPtr<Expression> lhs) + UnaryExpression(UnaryOp op, NonnullRefPtr<Expression> lhs) : m_op(op) , m_lhs(move(lhs)) { @@ -327,7 +334,7 @@ private: virtual const char* class_name() const override { return "UnaryExpression"; } UnaryOp m_op; - NonnullOwnPtr<Expression> m_lhs; + NonnullRefPtr<Expression> m_lhs; }; class Literal : public Expression { @@ -432,7 +439,7 @@ private: class CallExpression : public Expression { public: - explicit CallExpression(NonnullOwnPtr<Expression> callee, NonnullOwnPtrVector<Expression> arguments = {}) + explicit CallExpression(NonnullRefPtr<Expression> callee, NonnullRefPtrVector<Expression> arguments = {}) : m_callee(move(callee)) , m_arguments(move(arguments)) { @@ -444,8 +451,8 @@ public: private: virtual const char* class_name() const override { return "CallExpression"; } - NonnullOwnPtr<Expression> m_callee; - const NonnullOwnPtrVector<Expression> m_arguments; + NonnullRefPtr<Expression> m_callee; + const NonnullRefPtrVector<Expression> m_arguments; }; enum class AssignmentOp { @@ -458,7 +465,7 @@ enum class AssignmentOp { class AssignmentExpression : public Expression { public: - AssignmentExpression(AssignmentOp op, NonnullOwnPtr<ASTNode> lhs, NonnullOwnPtr<Expression> rhs) + AssignmentExpression(AssignmentOp op, NonnullRefPtr<ASTNode> lhs, NonnullRefPtr<Expression> rhs) : m_op(op) , m_lhs(move(lhs)) , m_rhs(move(rhs)) @@ -472,8 +479,8 @@ private: virtual const char* class_name() const override { return "AssignmentExpression"; } AssignmentOp m_op; - NonnullOwnPtr<ASTNode> m_lhs; - NonnullOwnPtr<Expression> m_rhs; + NonnullRefPtr<ASTNode> m_lhs; + NonnullRefPtr<Expression> m_rhs; }; enum class UpdateOp { @@ -483,7 +490,7 @@ enum class UpdateOp { class UpdateExpression : public Expression { public: - UpdateExpression(UpdateOp op, NonnullOwnPtr<Expression> argument, bool prefixed = false) + UpdateExpression(UpdateOp op, NonnullRefPtr<Expression> argument, bool prefixed = false) : m_op(op) , m_argument(move(argument)) , m_prefixed(prefixed) @@ -497,7 +504,7 @@ private: virtual const char* class_name() const override { return "UpdateExpression"; } UpdateOp m_op; - NonnullOwnPtr<Identifier> m_argument; + NonnullRefPtr<Identifier> m_argument; bool m_prefixed; }; @@ -509,7 +516,7 @@ enum class DeclarationType { class VariableDeclaration : public Statement { public: - VariableDeclaration(NonnullOwnPtr<Identifier> name, OwnPtr<Expression> initializer, DeclarationType declaration_type) + VariableDeclaration(NonnullRefPtr<Identifier> name, RefPtr<Expression> initializer, DeclarationType declaration_type) : m_declaration_type(declaration_type) , m_name(move(name)) , m_initializer(move(initializer)) @@ -527,8 +534,8 @@ private: virtual const char* class_name() const override { return "VariableDeclaration"; } DeclarationType m_declaration_type; - NonnullOwnPtr<Identifier> m_name; - OwnPtr<Expression> m_initializer; + NonnullRefPtr<Identifier> m_name; + RefPtr<Expression> m_initializer; }; class ObjectExpression : public Expression { @@ -544,7 +551,7 @@ private: class MemberExpression final : public Expression { public: - MemberExpression(NonnullOwnPtr<Expression> object, NonnullOwnPtr<Expression> property) + MemberExpression(NonnullRefPtr<Expression> object, NonnullRefPtr<Expression> property) : m_object(move(object)) , m_property(move(property)) { @@ -559,8 +566,8 @@ private: virtual bool is_member_expression() const override { return true; } virtual const char* class_name() const override { return "MemberExpression"; } - NonnullOwnPtr<Expression> m_object; - NonnullOwnPtr<Expression> m_property; + NonnullRefPtr<Expression> m_object; + NonnullRefPtr<Expression> m_property; }; } diff --git a/Libraries/LibJS/Interpreter.cpp b/Libraries/LibJS/Interpreter.cpp index 97645092de..8f36fe58e2 100644 --- a/Libraries/LibJS/Interpreter.cpp +++ b/Libraries/LibJS/Interpreter.cpp @@ -72,7 +72,7 @@ void Interpreter::enter_scope(const ScopeNode& scope_node, Vector<Argument> argu void Interpreter::exit_scope(const ScopeNode& scope_node) { - while (&m_scope_stack.last().scope_node != &scope_node) + while (m_scope_stack.last().scope_node.ptr() != &scope_node) m_scope_stack.take_last(); } diff --git a/Libraries/LibJS/Interpreter.h b/Libraries/LibJS/Interpreter.h index 897c210c32..727cc67629 100644 --- a/Libraries/LibJS/Interpreter.h +++ b/Libraries/LibJS/Interpreter.h @@ -47,7 +47,7 @@ struct Variable { struct ScopeFrame { ScopeType type; - const ScopeNode& scope_node; + NonnullRefPtr<ScopeNode> scope_node; HashMap<String, Variable> variables; }; diff --git a/Libraries/LibJS/Parser.cpp b/Libraries/LibJS/Parser.cpp index dbc307ba4e..051fec8983 100644 --- a/Libraries/LibJS/Parser.cpp +++ b/Libraries/LibJS/Parser.cpp @@ -163,9 +163,9 @@ Associativity Parser::operator_associativity(TokenType type) const } } -NonnullOwnPtr<Program> Parser::parse_program() +NonnullRefPtr<Program> Parser::parse_program() { - auto program = make<Program>(); + auto program = adopt(*new Program); while (!done()) { if (match(TokenType::Semicolon)) { consume(); @@ -179,10 +179,10 @@ NonnullOwnPtr<Program> Parser::parse_program() return program; } -NonnullOwnPtr<Statement> Parser::parse_statement() +NonnullRefPtr<Statement> Parser::parse_statement() { if (match_expression()) { - return make<JS::ExpressionStatement>(parse_expression(0)); + return adopt(*new ExpressionStatement(parse_expression(0))); } switch (m_current_token.type()) { @@ -202,11 +202,11 @@ NonnullOwnPtr<Statement> Parser::parse_statement() m_has_errors = true; expected("statement (missing switch case)"); consume(); - return make<ErrorStatement>(); + return create_ast_node<ErrorStatement>(); } } -NonnullOwnPtr<Expression> Parser::parse_primary_expression() +NonnullRefPtr<Expression> Parser::parse_primary_expression() { switch (m_current_token.type()) { case TokenType::ParenOpen: { @@ -216,64 +216,64 @@ NonnullOwnPtr<Expression> Parser::parse_primary_expression() return expression; } case TokenType::Identifier: - return make<Identifier>(consume().value()); + return create_ast_node<Identifier>(consume().value()); case TokenType::NumericLiteral: - return make<NumericLiteral>(consume().double_value()); + return create_ast_node<NumericLiteral>(consume().double_value()); case TokenType::BoolLiteral: - return make<BooleanLiteral>(consume().bool_value()); + return create_ast_node<BooleanLiteral>(consume().bool_value()); case TokenType::StringLiteral: - return make<StringLiteral>(consume().string_value()); + return create_ast_node<StringLiteral>(consume().string_value()); case TokenType::NullLiteral: consume(); - return make<NullLiteral>(); + return create_ast_node<NullLiteral>(); case TokenType::UndefinedLiteral: consume(); - return make<UndefinedLiteral>(); + return create_ast_node<UndefinedLiteral>(); case TokenType::CurlyOpen: return parse_object_expression(); default: m_has_errors = true; expected("primary expression (missing switch case)"); consume(); - return make<ErrorExpression>(); + return create_ast_node<ErrorExpression>(); } } -NonnullOwnPtr<Expression> Parser::parse_unary_prefixed_expression() +NonnullRefPtr<Expression> Parser::parse_unary_prefixed_expression() { switch (m_current_token.type()) { case TokenType::PlusPlus: consume(); - return make<UpdateExpression>(UpdateOp::Increment, parse_primary_expression(), true); + return create_ast_node<UpdateExpression>(UpdateOp::Increment, parse_primary_expression(), true); case TokenType::MinusMinus: consume(); - return make<UpdateExpression>(UpdateOp::Decrement, parse_primary_expression(), true); + return create_ast_node<UpdateExpression>(UpdateOp::Decrement, parse_primary_expression(), true); case TokenType::ExclamationMark: consume(); - return make<UnaryExpression>(UnaryOp::Not, parse_primary_expression()); + return create_ast_node<UnaryExpression>(UnaryOp::Not, parse_primary_expression()); case TokenType::Tilde: consume(); - return make<UnaryExpression>(UnaryOp::BitwiseNot, parse_primary_expression()); + return create_ast_node<UnaryExpression>(UnaryOp::BitwiseNot, parse_primary_expression()); case TokenType::Typeof: consume(); - return make<UnaryExpression>(UnaryOp::Typeof, parse_primary_expression()); + return create_ast_node<UnaryExpression>(UnaryOp::Typeof, parse_primary_expression()); default: m_has_errors = true; expected("primary expression (missing switch case)"); consume(); - return make<ErrorExpression>(); + return create_ast_node<ErrorExpression>(); } } -NonnullOwnPtr<ObjectExpression> Parser::parse_object_expression() +NonnullRefPtr<ObjectExpression> Parser::parse_object_expression() { // FIXME: Parse actual object expression consume(TokenType::CurlyOpen); consume(TokenType::CurlyClose); - return make<ObjectExpression>(); + return create_ast_node<ObjectExpression>(); } -NonnullOwnPtr<Expression> Parser::parse_expression(int min_precedence, Associativity associativity) +NonnullRefPtr<Expression> Parser::parse_expression(int min_precedence, Associativity associativity) { if (match_unary_prefixed_expression()) return parse_unary_prefixed_expression(); @@ -292,90 +292,90 @@ NonnullOwnPtr<Expression> Parser::parse_expression(int min_precedence, Associati return expression; } -NonnullOwnPtr<Expression> Parser::parse_secondary_expression(NonnullOwnPtr<Expression> lhs, int min_precedence, Associativity associativity) +NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expression> lhs, int min_precedence, Associativity associativity) { switch (m_current_token.type()) { case TokenType::Plus: consume(); - return make<BinaryExpression>(BinaryOp::Plus, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::Plus, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::PlusEquals: consume(); - return make<AssignmentExpression>(AssignmentOp::AdditionAssignment, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<AssignmentExpression>(AssignmentOp::AdditionAssignment, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Minus: consume(); - return make<BinaryExpression>(BinaryOp::Minus, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::Minus, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::MinusEquals: consume(); - return make<AssignmentExpression>(AssignmentOp::SubtractionAssignment, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<AssignmentExpression>(AssignmentOp::SubtractionAssignment, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Asterisk: consume(); - return make<BinaryExpression>(BinaryOp::Asterisk, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::Asterisk, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::AsteriskEquals: consume(); - return make<AssignmentExpression>(AssignmentOp::MultiplicationAssignment, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<AssignmentExpression>(AssignmentOp::MultiplicationAssignment, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Slash: consume(); - return make<BinaryExpression>(BinaryOp::Slash, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::Slash, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::SlashEquals: consume(); - return make<AssignmentExpression>(AssignmentOp::DivisionAssignment, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<AssignmentExpression>(AssignmentOp::DivisionAssignment, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::GreaterThan: consume(); - return make<BinaryExpression>(BinaryOp::GreaterThan, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::GreaterThan, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::GreaterThanEquals: consume(); - return make<BinaryExpression>(BinaryOp::GreaterThanEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::GreaterThanEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::LessThan: consume(); - return make<BinaryExpression>(BinaryOp::LessThan, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::LessThan, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::LessThanEquals: consume(); - return make<BinaryExpression>(BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::EqualsEqualsEquals: consume(); - return make<BinaryExpression>(BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ExclamationMarkEqualsEquals: consume(); - return make<BinaryExpression>(BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::EqualsEquals: consume(); - return make<BinaryExpression>(BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ExclamationMarkEquals: consume(); - return make<BinaryExpression>(BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<BinaryExpression>(BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ParenOpen: return parse_call_expression(move(lhs)); case TokenType::Equals: consume(); - return make<AssignmentExpression>(AssignmentOp::Assignment, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<AssignmentExpression>(AssignmentOp::Assignment, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Period: consume(); - return make<MemberExpression>(move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<MemberExpression>(move(lhs), parse_expression(min_precedence, associativity)); case TokenType::PlusPlus: consume(); - return make<UpdateExpression>(UpdateOp::Increment, move(lhs)); + return create_ast_node<UpdateExpression>(UpdateOp::Increment, move(lhs)); case TokenType::MinusMinus: consume(); - return make<UpdateExpression>(UpdateOp::Decrement, move(lhs)); + return create_ast_node<UpdateExpression>(UpdateOp::Decrement, move(lhs)); case TokenType::DoubleAmpersand: consume(); - return make<LogicalExpression>(LogicalOp::And, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<LogicalExpression>(LogicalOp::And, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::DoublePipe: consume(); - return make<LogicalExpression>(LogicalOp::Or, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node<LogicalExpression>(LogicalOp::Or, move(lhs), parse_expression(min_precedence, associativity)); default: m_has_errors = true; expected("secondary expression (missing switch case)"); consume(); - return make<ErrorExpression>(); + return create_ast_node<ErrorExpression>(); } } -NonnullOwnPtr<CallExpression> Parser::parse_call_expression(NonnullOwnPtr<Expression> lhs) +NonnullRefPtr<CallExpression> Parser::parse_call_expression(NonnullRefPtr<Expression> lhs) { consume(TokenType::ParenOpen); - NonnullOwnPtrVector<Expression> arguments; + NonnullRefPtrVector<Expression> arguments; while (match_expression()) { arguments.append(parse_expression(0)); @@ -386,21 +386,21 @@ NonnullOwnPtr<CallExpression> Parser::parse_call_expression(NonnullOwnPtr<Expres consume(TokenType::ParenClose); - return make<CallExpression>(move(lhs), move(arguments)); + return create_ast_node<CallExpression>(move(lhs), move(arguments)); } -NonnullOwnPtr<ReturnStatement> Parser::parse_return_statement() +NonnullRefPtr<ReturnStatement> Parser::parse_return_statement() { consume(TokenType::Return); if (match_expression()) { - return make<ReturnStatement>(parse_expression(0)); + return create_ast_node<ReturnStatement>(parse_expression(0)); } - return make<ReturnStatement>(nullptr); + return create_ast_node<ReturnStatement>(nullptr); } -NonnullOwnPtr<BlockStatement> Parser::parse_block_statement() +NonnullRefPtr<BlockStatement> Parser::parse_block_statement() { - auto block = make<BlockStatement>(); + auto block = create_ast_node<BlockStatement>(); consume(TokenType::CurlyOpen); while (!done() && !match(TokenType::CurlyClose)) { if (match(TokenType::Semicolon)) { @@ -416,7 +416,7 @@ NonnullOwnPtr<BlockStatement> Parser::parse_block_statement() return block; } -NonnullOwnPtr<FunctionDeclaration> Parser::parse_function_declaration() +NonnullRefPtr<FunctionDeclaration> Parser::parse_function_declaration() { consume(TokenType::Function); auto name = consume(TokenType::Identifier).value(); @@ -432,10 +432,10 @@ NonnullOwnPtr<FunctionDeclaration> Parser::parse_function_declaration() } consume(TokenType::ParenClose); auto body = parse_block_statement(); - return make<FunctionDeclaration>(name, move(body), move(parameters)); + return create_ast_node<FunctionDeclaration>(name, move(body), move(parameters)); } -NonnullOwnPtr<VariableDeclaration> Parser::parse_variable_declaration() +NonnullRefPtr<VariableDeclaration> Parser::parse_variable_declaration() { DeclarationType declaration_type; @@ -456,21 +456,21 @@ NonnullOwnPtr<VariableDeclaration> Parser::parse_variable_declaration() ASSERT_NOT_REACHED(); } auto name = consume(TokenType::Identifier).value(); - OwnPtr<Expression> initializer; + RefPtr<Expression> initializer; if (match(TokenType::Equals)) { consume(); initializer = parse_expression(0); } - return make<VariableDeclaration>(make<Identifier>(name), move(initializer), declaration_type); + return create_ast_node<VariableDeclaration>(create_ast_node<Identifier>(name), move(initializer), declaration_type); } -NonnullOwnPtr<ForStatement> Parser::parse_for_statement() +NonnullRefPtr<ForStatement> Parser::parse_for_statement() { consume(TokenType::For); consume(TokenType::ParenOpen); - OwnPtr<Statement> init = nullptr; + RefPtr<Statement> init; switch (m_current_token.type()) { case TokenType::Semicolon: break; @@ -481,7 +481,7 @@ NonnullOwnPtr<ForStatement> Parser::parse_for_statement() consume(TokenType::Semicolon); - OwnPtr<Expression> test = nullptr; + RefPtr<Expression> test; switch (m_current_token.type()) { case TokenType::Semicolon: break; @@ -492,7 +492,7 @@ NonnullOwnPtr<ForStatement> Parser::parse_for_statement() consume(TokenType::Semicolon); - OwnPtr<Expression> update = nullptr; + RefPtr<Expression> update; switch (m_current_token.type()) { case TokenType::Semicolon: break; @@ -505,7 +505,7 @@ NonnullOwnPtr<ForStatement> Parser::parse_for_statement() auto body = parse_block_statement(); - return make<ForStatement>(move(init), move(test), move(update), move(body)); + return create_ast_node<ForStatement>(move(init), move(test), move(update), move(body)); } bool Parser::match(TokenType type) const diff --git a/Libraries/LibJS/Parser.h b/Libraries/LibJS/Parser.h index 003a4ea2fb..229c507e11 100644 --- a/Libraries/LibJS/Parser.h +++ b/Libraries/LibJS/Parser.h @@ -28,7 +28,7 @@ #include "AST.h" #include "Lexer.h" -#include <AK/NonnullOwnPtr.h> +#include <AK/NonnullRefPtr.h> namespace JS { @@ -41,21 +41,21 @@ class Parser { public: explicit Parser(Lexer lexer); - NonnullOwnPtr<Program> parse_program(); + NonnullRefPtr<Program> parse_program(); - NonnullOwnPtr<Statement> parse_statement(); - NonnullOwnPtr<BlockStatement> parse_block_statement(); - NonnullOwnPtr<ReturnStatement> parse_return_statement(); - NonnullOwnPtr<FunctionDeclaration> parse_function_declaration(); - NonnullOwnPtr<VariableDeclaration> parse_variable_declaration(); - NonnullOwnPtr<ForStatement> parse_for_statement(); + NonnullRefPtr<Statement> parse_statement(); + NonnullRefPtr<BlockStatement> parse_block_statement(); + NonnullRefPtr<ReturnStatement> parse_return_statement(); + NonnullRefPtr<FunctionDeclaration> parse_function_declaration(); + NonnullRefPtr<VariableDeclaration> parse_variable_declaration(); + NonnullRefPtr<ForStatement> parse_for_statement(); - NonnullOwnPtr<Expression> parse_expression(int min_precedence, Associativity associate = Associativity::Right); - NonnullOwnPtr<Expression> parse_primary_expression(); - NonnullOwnPtr<Expression> parse_unary_prefixed_expression(); - NonnullOwnPtr<ObjectExpression> parse_object_expression(); - NonnullOwnPtr<Expression> parse_secondary_expression(NonnullOwnPtr<Expression>, int min_precedence, Associativity associate = Associativity::Right); - NonnullOwnPtr<CallExpression> parse_call_expression(NonnullOwnPtr<Expression>); + NonnullRefPtr<Expression> parse_expression(int min_precedence, Associativity associate = Associativity::Right); + NonnullRefPtr<Expression> parse_primary_expression(); + NonnullRefPtr<Expression> parse_unary_prefixed_expression(); + NonnullRefPtr<ObjectExpression> parse_object_expression(); + NonnullRefPtr<Expression> parse_secondary_expression(NonnullRefPtr<Expression>, int min_precedence, Associativity associate = Associativity::Right); + NonnullRefPtr<CallExpression> parse_call_expression(NonnullRefPtr<Expression>); bool has_errors() const { return m_has_errors; } diff --git a/Libraries/LibJS/Runtime/ScriptFunction.cpp b/Libraries/LibJS/Runtime/ScriptFunction.cpp index 62cb98f20e..b7a766bfe3 100644 --- a/Libraries/LibJS/Runtime/ScriptFunction.cpp +++ b/Libraries/LibJS/Runtime/ScriptFunction.cpp @@ -24,6 +24,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include <LibJS/AST.h> #include <LibJS/Interpreter.h> #include <LibJS/Runtime/ScriptFunction.h> #include <LibJS/Runtime/Value.h> diff --git a/Libraries/LibJS/Runtime/ScriptFunction.h b/Libraries/LibJS/Runtime/ScriptFunction.h index 6643cbbfb5..4d3fc4b2c1 100644 --- a/Libraries/LibJS/Runtime/ScriptFunction.h +++ b/Libraries/LibJS/Runtime/ScriptFunction.h @@ -44,7 +44,7 @@ private: virtual bool is_script_function() const final { return true; } virtual const char* class_name() const override { return "ScriptFunction"; } - const ScopeNode& m_body; + NonnullRefPtr<ScopeNode> m_body; const Vector<String> m_parameters; }; |