123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140 |
- /*
- * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
- * 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.
- */
- #pragma once
- #include <AK/FlyString.h>
- #include <AK/HashMap.h>
- #include <AK/NonnullRefPtrVector.h>
- #include <AK/RefPtr.h>
- #include <AK/String.h>
- #include <AK/Vector.h>
- #include <LibJS/Forward.h>
- #include <LibJS/Runtime/PropertyName.h>
- #include <LibJS/Runtime/Value.h>
- namespace JS {
- class VariableDeclaration;
- class FunctionDeclaration;
- 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;
- virtual Value execute(Interpreter&, GlobalObject&) const = 0;
- virtual void dump(int indent) const;
- virtual bool is_identifier() const { return false; }
- virtual bool is_spread_expression() const { return false; }
- virtual bool is_member_expression() const { return false; }
- virtual bool is_scope_node() const { return false; }
- virtual bool is_program() const { return false; }
- virtual bool is_variable_declaration() const { return false; }
- virtual bool is_call_expression() const { return false; }
- virtual bool is_new_expression() const { return false; }
- protected:
- ASTNode() { }
- private:
- };
- class Statement : public ASTNode {
- public:
- const FlyString& label() const { return m_label; }
- void set_label(FlyString string) { m_label = string; }
- protected:
- FlyString m_label;
- };
- class EmptyStatement final : public Statement {
- public:
- Value execute(Interpreter&, GlobalObject&) const override { return js_undefined(); }
- const char* class_name() const override { return "EmptyStatement"; }
- };
- class ErrorStatement final : public Statement {
- public:
- Value execute(Interpreter&, GlobalObject&) const override { return js_undefined(); }
- const char* class_name() const override { return "ErrorStatement"; }
- };
- class ExpressionStatement final : public Statement {
- public:
- ExpressionStatement(NonnullRefPtr<Expression> expression)
- : m_expression(move(expression))
- {
- }
- Value execute(Interpreter&, GlobalObject&) const override;
- const char* class_name() const override { return "ExpressionStatement"; }
- virtual void dump(int indent) const override;
- private:
- NonnullRefPtr<Expression> m_expression;
- };
- class ScopeNode : public Statement {
- public:
- template<typename T, typename... Args>
- T& append(Args&&... args)
- {
- auto child = create_ast_node<T>(forward<Args>(args)...);
- m_children.append(move(child));
- return static_cast<T&>(m_children.last());
- }
- void append(NonnullRefPtr<Statement> child)
- {
- m_children.append(move(child));
- }
- const NonnullRefPtrVector<Statement>& children() const { return m_children; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- void add_variables(NonnullRefPtrVector<VariableDeclaration>);
- void add_functions(NonnullRefPtrVector<FunctionDeclaration>);
- const NonnullRefPtrVector<VariableDeclaration>& variables() const { return m_variables; }
- const NonnullRefPtrVector<FunctionDeclaration>& functions() const { return m_functions; }
- bool in_strict_mode() const { return m_strict_mode; }
- void set_strict_mode() { m_strict_mode = true; }
- protected:
- ScopeNode() { }
- private:
- virtual bool is_scope_node() const final { return true; }
- NonnullRefPtrVector<Statement> m_children;
- NonnullRefPtrVector<VariableDeclaration> m_variables;
- NonnullRefPtrVector<FunctionDeclaration> m_functions;
- bool m_strict_mode { false };
- };
- class Program : public ScopeNode {
- public:
- Program() { }
- private:
- virtual bool is_program() const override { return true; }
- virtual const char* class_name() const override { return "Program"; }
- };
- class BlockStatement : public ScopeNode {
- public:
- BlockStatement() { }
- private:
- virtual const char* class_name() const override { return "BlockStatement"; }
- };
- class Expression : public ASTNode {
- public:
- virtual Reference to_reference(Interpreter&, GlobalObject&) const;
- };
- class Declaration : public Statement {
- };
- class FunctionNode {
- public:
- struct Parameter {
- FlyString name;
- RefPtr<Expression> default_value;
- bool is_rest { false };
- };
- const FlyString& name() const { return m_name; }
- const Statement& body() const { return *m_body; }
- const Vector<Parameter>& parameters() const { return m_parameters; };
- i32 function_length() const { return m_function_length; }
- protected:
- FunctionNode(const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables)
- : m_name(name)
- , m_body(move(body))
- , m_parameters(move(parameters))
- , m_variables(move(variables))
- , m_function_length(function_length)
- {
- }
- void dump(int indent, const char* class_name) const;
- const NonnullRefPtrVector<VariableDeclaration>& variables() const { return m_variables; }
- private:
- FlyString m_name;
- NonnullRefPtr<Statement> m_body;
- const Vector<Parameter> m_parameters;
- NonnullRefPtrVector<VariableDeclaration> m_variables;
- const i32 m_function_length;
- };
- class FunctionDeclaration final
- : public Declaration
- , public FunctionNode {
- public:
- static bool must_have_name() { return true; }
- FunctionDeclaration(const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables)
- : FunctionNode(name, move(body), move(parameters), function_length, move(variables))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "FunctionDeclaration"; }
- };
- class FunctionExpression final
- : public Expression
- , public FunctionNode {
- public:
- static bool must_have_name() { return false; }
- FunctionExpression(const FlyString& name, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, NonnullRefPtrVector<VariableDeclaration> variables, bool is_arrow_function = false)
- : FunctionNode(name, move(body), move(parameters), function_length, move(variables))
- , m_is_arrow_function(is_arrow_function)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "FunctionExpression"; }
- bool m_is_arrow_function;
- };
- class ErrorExpression final : public Expression {
- public:
- Value execute(Interpreter&, GlobalObject&) const override { return js_undefined(); }
- const char* class_name() const override { return "ErrorExpression"; }
- };
- class ReturnStatement : public Statement {
- public:
- explicit ReturnStatement(RefPtr<Expression> argument)
- : m_argument(move(argument))
- {
- }
- const Expression* argument() const { return m_argument; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ReturnStatement"; }
- RefPtr<Expression> m_argument;
- };
- class IfStatement : public Statement {
- public:
- IfStatement(NonnullRefPtr<Expression> predicate, NonnullRefPtr<Statement> consequent, RefPtr<Statement> alternate)
- : m_predicate(move(predicate))
- , m_consequent(move(consequent))
- , m_alternate(move(alternate))
- {
- }
- const Expression& predicate() const { return *m_predicate; }
- const Statement& consequent() const { return *m_consequent; }
- const Statement* alternate() const { return m_alternate; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "IfStatement"; }
- NonnullRefPtr<Expression> m_predicate;
- NonnullRefPtr<Statement> m_consequent;
- RefPtr<Statement> m_alternate;
- };
- class WhileStatement : public Statement {
- public:
- WhileStatement(NonnullRefPtr<Expression> test, NonnullRefPtr<Statement> body)
- : m_test(move(test))
- , m_body(move(body))
- {
- }
- const Expression& test() const { return *m_test; }
- const Statement& body() const { return *m_body; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "WhileStatement"; }
- NonnullRefPtr<Expression> m_test;
- NonnullRefPtr<Statement> m_body;
- };
- class DoWhileStatement : public Statement {
- public:
- DoWhileStatement(NonnullRefPtr<Expression> test, NonnullRefPtr<Statement> body)
- : m_test(move(test))
- , m_body(move(body))
- {
- }
- const Expression& test() const { return *m_test; }
- const Statement& body() const { return *m_body; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "DoWhileStatement"; }
- NonnullRefPtr<Expression> m_test;
- NonnullRefPtr<Statement> m_body;
- };
- class ForStatement : public Statement {
- public:
- ForStatement(RefPtr<ASTNode> init, RefPtr<Expression> test, RefPtr<Expression> update, NonnullRefPtr<Statement> body)
- : m_init(move(init))
- , m_test(move(test))
- , m_update(move(update))
- , m_body(move(body))
- {
- }
- const ASTNode* init() const { return m_init; }
- const Expression* test() const { return m_test; }
- const Expression* update() const { return m_update; }
- const Statement& body() const { return *m_body; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ForStatement"; }
- RefPtr<ASTNode> m_init;
- RefPtr<Expression> m_test;
- RefPtr<Expression> m_update;
- NonnullRefPtr<Statement> m_body;
- };
- class ForInStatement : public Statement {
- public:
- ForInStatement(NonnullRefPtr<ASTNode> lhs, NonnullRefPtr<Expression> rhs, NonnullRefPtr<Statement> body)
- : m_lhs(move(lhs))
- , m_rhs(move(rhs))
- , m_body(move(body))
- {
- }
- const ASTNode& lhs() const { return *m_lhs; }
- const Expression& rhs() const { return *m_rhs; }
- const Statement& body() const { return *m_body; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ForInStatement"; }
- NonnullRefPtr<ASTNode> m_lhs;
- NonnullRefPtr<Expression> m_rhs;
- NonnullRefPtr<Statement> m_body;
- };
- class ForOfStatement : public Statement {
- public:
- ForOfStatement(NonnullRefPtr<ASTNode> lhs, NonnullRefPtr<Expression> rhs, NonnullRefPtr<Statement> body)
- : m_lhs(move(lhs))
- , m_rhs(move(rhs))
- , m_body(move(body))
- {
- }
- const ASTNode& lhs() const { return *m_lhs; }
- const Expression& rhs() const { return *m_rhs; }
- const Statement& body() const { return *m_body; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ForOfStatement"; }
- NonnullRefPtr<ASTNode> m_lhs;
- NonnullRefPtr<Expression> m_rhs;
- NonnullRefPtr<Statement> m_body;
- };
- enum class BinaryOp {
- Addition,
- Subtraction,
- Multiplication,
- Division,
- Modulo,
- Exponentiation,
- TypedEquals,
- TypedInequals,
- AbstractEquals,
- AbstractInequals,
- GreaterThan,
- GreaterThanEquals,
- LessThan,
- LessThanEquals,
- BitwiseAnd,
- BitwiseOr,
- BitwiseXor,
- LeftShift,
- RightShift,
- UnsignedRightShift,
- In,
- InstanceOf,
- };
- class BinaryExpression : public Expression {
- public:
- BinaryExpression(BinaryOp op, NonnullRefPtr<Expression> lhs, NonnullRefPtr<Expression> rhs)
- : m_op(op)
- , m_lhs(move(lhs))
- , m_rhs(move(rhs))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "BinaryExpression"; }
- BinaryOp m_op;
- NonnullRefPtr<Expression> m_lhs;
- NonnullRefPtr<Expression> m_rhs;
- };
- enum class LogicalOp {
- And,
- Or,
- NullishCoalescing,
- };
- class LogicalExpression : public Expression {
- public:
- LogicalExpression(LogicalOp op, NonnullRefPtr<Expression> lhs, NonnullRefPtr<Expression> rhs)
- : m_op(op)
- , m_lhs(move(lhs))
- , m_rhs(move(rhs))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "LogicalExpression"; }
- LogicalOp m_op;
- NonnullRefPtr<Expression> m_lhs;
- NonnullRefPtr<Expression> m_rhs;
- };
- enum class UnaryOp {
- BitwiseNot,
- Not,
- Plus,
- Minus,
- Typeof,
- Void,
- Delete,
- };
- class UnaryExpression : public Expression {
- public:
- UnaryExpression(UnaryOp op, NonnullRefPtr<Expression> lhs)
- : m_op(op)
- , m_lhs(move(lhs))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "UnaryExpression"; }
- UnaryOp m_op;
- NonnullRefPtr<Expression> m_lhs;
- };
- class SequenceExpression final : public Expression {
- public:
- SequenceExpression(NonnullRefPtrVector<Expression> expressions)
- : m_expressions(move(expressions))
- {
- }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "SequenceExpression"; }
- NonnullRefPtrVector<Expression> m_expressions;
- };
- class Literal : public Expression {
- protected:
- explicit Literal() { }
- };
- class BooleanLiteral final : public Literal {
- public:
- explicit BooleanLiteral(bool value)
- : m_value(value)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "BooleanLiteral"; }
- bool m_value { false };
- };
- class NumericLiteral final : public Literal {
- public:
- explicit NumericLiteral(double value)
- : m_value(value)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "NumericLiteral"; }
- double m_value { 0 };
- };
- class BigIntLiteral final : public Literal {
- public:
- explicit BigIntLiteral(String value)
- : m_value(move(value))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "BigIntLiteral"; }
- String m_value;
- };
- class StringLiteral final : public Literal {
- public:
- explicit StringLiteral(String value)
- : m_value(move(value))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "StringLiteral"; }
- String m_value;
- };
- class NullLiteral final : public Literal {
- public:
- explicit NullLiteral() { }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "NullLiteral"; }
- };
- class RegExpLiteral final : public Literal {
- public:
- explicit RegExpLiteral(String content, String flags)
- : m_content(content)
- , m_flags(flags)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- const String& content() const { return m_content; }
- const String& flags() const { return m_flags; }
- private:
- virtual const char* class_name() const override { return "RegexLiteral"; }
- String m_content;
- String m_flags;
- };
- class Identifier final : public Expression {
- public:
- explicit Identifier(const FlyString& string)
- : m_string(string)
- {
- }
- const FlyString& string() const { return m_string; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- virtual bool is_identifier() const override { return true; }
- virtual Reference to_reference(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "Identifier"; }
- FlyString m_string;
- };
- class SpreadExpression final : public Expression {
- public:
- explicit SpreadExpression(NonnullRefPtr<Expression> target)
- : m_target(target)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- virtual bool is_spread_expression() const override { return true; }
- private:
- virtual const char* class_name() const override { return "SpreadExpression"; }
- NonnullRefPtr<Expression> m_target;
- };
- class ThisExpression final : public Expression {
- public:
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ThisExpression"; }
- };
- class CallExpression : public Expression {
- public:
- struct Argument {
- NonnullRefPtr<Expression> value;
- bool is_spread;
- };
- CallExpression(NonnullRefPtr<Expression> callee, Vector<Argument> arguments = {})
- : m_callee(move(callee))
- , m_arguments(move(arguments))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "CallExpression"; }
- virtual bool is_call_expression() const override { return true; }
- struct ThisAndCallee {
- Value this_value;
- Value callee;
- };
- ThisAndCallee compute_this_and_callee(Interpreter&, GlobalObject&) const;
- NonnullRefPtr<Expression> m_callee;
- const Vector<Argument> m_arguments;
- };
- class NewExpression final : public CallExpression {
- public:
- NewExpression(NonnullRefPtr<Expression> callee, Vector<Argument> arguments = {})
- : CallExpression(move(callee), move(arguments))
- {
- }
- private:
- virtual const char* class_name() const override { return "NewExpression"; }
- virtual bool is_call_expression() const override { return false; }
- virtual bool is_new_expression() const override { return true; }
- };
- enum class AssignmentOp {
- Assignment,
- AdditionAssignment,
- SubtractionAssignment,
- MultiplicationAssignment,
- DivisionAssignment,
- ModuloAssignment,
- ExponentiationAssignment,
- BitwiseAndAssignment,
- BitwiseOrAssignment,
- BitwiseXorAssignment,
- LeftShiftAssignment,
- RightShiftAssignment,
- UnsignedRightShiftAssignment,
- };
- class AssignmentExpression : public Expression {
- public:
- AssignmentExpression(AssignmentOp op, NonnullRefPtr<Expression> lhs, NonnullRefPtr<Expression> rhs)
- : m_op(op)
- , m_lhs(move(lhs))
- , m_rhs(move(rhs))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "AssignmentExpression"; }
- AssignmentOp m_op;
- NonnullRefPtr<Expression> m_lhs;
- NonnullRefPtr<Expression> m_rhs;
- };
- enum class UpdateOp {
- Increment,
- Decrement,
- };
- class UpdateExpression : public Expression {
- public:
- UpdateExpression(UpdateOp op, NonnullRefPtr<Expression> argument, bool prefixed = false)
- : m_op(op)
- , m_argument(move(argument))
- , m_prefixed(prefixed)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "UpdateExpression"; }
- UpdateOp m_op;
- NonnullRefPtr<Expression> m_argument;
- bool m_prefixed;
- };
- enum class DeclarationKind {
- Var,
- Let,
- Const,
- };
- class VariableDeclarator final : public ASTNode {
- public:
- VariableDeclarator(NonnullRefPtr<Identifier> id)
- : m_id(move(id))
- {
- }
- VariableDeclarator(NonnullRefPtr<Identifier> id, RefPtr<Expression> init)
- : m_id(move(id))
- , m_init(move(init))
- {
- }
- const Identifier& id() const { return m_id; }
- const Expression* init() const { return m_init; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "VariableDeclarator"; }
- NonnullRefPtr<Identifier> m_id;
- RefPtr<Expression> m_init;
- };
- class VariableDeclaration : public Declaration {
- public:
- VariableDeclaration(DeclarationKind declaration_kind, NonnullRefPtrVector<VariableDeclarator> declarations)
- : m_declaration_kind(declaration_kind)
- , m_declarations(move(declarations))
- {
- }
- virtual bool is_variable_declaration() const override { return true; }
- DeclarationKind declaration_kind() const { return m_declaration_kind; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- const NonnullRefPtrVector<VariableDeclarator>& declarations() const { return m_declarations; }
- private:
- virtual const char* class_name() const override { return "VariableDeclaration"; }
- DeclarationKind m_declaration_kind;
- NonnullRefPtrVector<VariableDeclarator> m_declarations;
- };
- class ObjectProperty final : public ASTNode {
- public:
- enum class Type {
- KeyValue,
- Getter,
- Setter,
- Spread,
- };
- ObjectProperty(NonnullRefPtr<Expression> key, RefPtr<Expression> value, Type property_type)
- : m_key(move(key))
- , m_value(move(value))
- , m_property_type(property_type)
- {
- }
- const Expression& key() const { return m_key; }
- const Expression& value() const
- {
- ASSERT(m_value);
- return *m_value;
- }
- Type type() const { return m_property_type; }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "ObjectProperty"; }
- NonnullRefPtr<Expression> m_key;
- RefPtr<Expression> m_value;
- Type m_property_type;
- };
- class ObjectExpression : public Expression {
- public:
- ObjectExpression(NonnullRefPtrVector<ObjectProperty> properties = {})
- : m_properties(move(properties))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ObjectExpression"; }
- NonnullRefPtrVector<ObjectProperty> m_properties;
- };
- class ArrayExpression : public Expression {
- public:
- ArrayExpression(Vector<RefPtr<Expression>> elements)
- : m_elements(move(elements))
- {
- }
- const Vector<RefPtr<Expression>>& elements() const { return m_elements; }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "ArrayExpression"; }
- Vector<RefPtr<Expression>> m_elements;
- };
- class TemplateLiteral final : public Expression {
- public:
- TemplateLiteral(NonnullRefPtrVector<Expression> expressions)
- : m_expressions(move(expressions))
- {
- }
- TemplateLiteral(NonnullRefPtrVector<Expression> expressions, NonnullRefPtrVector<Expression> raw_strings)
- : m_expressions(move(expressions))
- , m_raw_strings(move(raw_strings))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- const NonnullRefPtrVector<Expression>& expressions() const { return m_expressions; }
- const NonnullRefPtrVector<Expression>& raw_strings() const { return m_raw_strings; }
- private:
- virtual const char* class_name() const override { return "TemplateLiteral"; }
- const NonnullRefPtrVector<Expression> m_expressions;
- const NonnullRefPtrVector<Expression> m_raw_strings;
- };
- class TaggedTemplateLiteral final : public Expression {
- public:
- TaggedTemplateLiteral(NonnullRefPtr<Expression> tag, NonnullRefPtr<TemplateLiteral> template_literal)
- : m_tag(move(tag))
- , m_template_literal(move(template_literal))
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- private:
- virtual const char* class_name() const override { return "TaggedTemplateLiteral"; }
- const NonnullRefPtr<Expression> m_tag;
- const NonnullRefPtr<TemplateLiteral> m_template_literal;
- };
- class MemberExpression final : public Expression {
- public:
- MemberExpression(NonnullRefPtr<Expression> object, NonnullRefPtr<Expression> property, bool computed = false)
- : m_object(move(object))
- , m_property(move(property))
- , m_computed(computed)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- virtual void dump(int indent) const override;
- virtual Reference to_reference(Interpreter&, GlobalObject&) const override;
- bool is_computed() const { return m_computed; }
- const Expression& object() const { return *m_object; }
- const Expression& property() const { return *m_property; }
- PropertyName computed_property_name(Interpreter&, GlobalObject&) const;
- String to_string_approximation() const;
- private:
- virtual bool is_member_expression() const override { return true; }
- virtual const char* class_name() const override { return "MemberExpression"; }
- NonnullRefPtr<Expression> m_object;
- NonnullRefPtr<Expression> m_property;
- bool m_computed { false };
- };
- class ConditionalExpression final : public Expression {
- public:
- ConditionalExpression(NonnullRefPtr<Expression> test, NonnullRefPtr<Expression> consequent, NonnullRefPtr<Expression> alternate)
- : m_test(move(test))
- , m_consequent(move(consequent))
- , m_alternate(move(alternate))
- {
- }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "ConditionalExpression"; }
- NonnullRefPtr<Expression> m_test;
- NonnullRefPtr<Expression> m_consequent;
- NonnullRefPtr<Expression> m_alternate;
- };
- class CatchClause final : public ASTNode {
- public:
- CatchClause(const FlyString& parameter, NonnullRefPtr<BlockStatement> body)
- : m_parameter(parameter)
- , m_body(move(body))
- {
- }
- const FlyString& parameter() const { return m_parameter; }
- const BlockStatement& body() const { return m_body; }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "CatchClause"; }
- FlyString m_parameter;
- NonnullRefPtr<BlockStatement> m_body;
- };
- class TryStatement final : public Statement {
- public:
- TryStatement(NonnullRefPtr<BlockStatement> block, RefPtr<CatchClause> handler, RefPtr<BlockStatement> finalizer)
- : m_block(move(block))
- , m_handler(move(handler))
- , m_finalizer(move(finalizer))
- {
- }
- const BlockStatement& block() const { return m_block; }
- const CatchClause* handler() const { return m_handler; }
- const BlockStatement* finalizer() const { return m_finalizer; }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "TryStatement"; }
- NonnullRefPtr<BlockStatement> m_block;
- RefPtr<CatchClause> m_handler;
- RefPtr<BlockStatement> m_finalizer;
- };
- class ThrowStatement final : public Statement {
- public:
- explicit ThrowStatement(NonnullRefPtr<Expression> argument)
- : m_argument(move(argument))
- {
- }
- const Expression& argument() const { return m_argument; }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "ThrowStatement"; }
- NonnullRefPtr<Expression> m_argument;
- };
- class SwitchCase final : public ASTNode {
- public:
- SwitchCase(RefPtr<Expression> test, NonnullRefPtrVector<Statement> consequent)
- : m_test(move(test))
- , m_consequent(move(consequent))
- {
- }
- const Expression* test() const { return m_test; }
- const NonnullRefPtrVector<Statement>& consequent() const { return m_consequent; }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "SwitchCase"; }
- RefPtr<Expression> m_test;
- NonnullRefPtrVector<Statement> m_consequent;
- };
- class SwitchStatement final : public Statement {
- public:
- SwitchStatement(NonnullRefPtr<Expression> discriminant, NonnullRefPtrVector<SwitchCase> cases)
- : m_discriminant(move(discriminant))
- , m_cases(move(cases))
- {
- }
- virtual void dump(int indent) const override;
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "SwitchStatement"; }
- NonnullRefPtr<Expression> m_discriminant;
- NonnullRefPtrVector<SwitchCase> m_cases;
- };
- class BreakStatement final : public Statement {
- public:
- BreakStatement(FlyString target_label)
- : m_target_label(target_label)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- const FlyString& target_label() const { return m_target_label; }
- private:
- virtual const char* class_name() const override { return "BreakStatement"; }
- FlyString m_target_label;
- };
- class ContinueStatement final : public Statement {
- public:
- ContinueStatement(FlyString target_label)
- : m_target_label(target_label)
- {
- }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- const FlyString& target_label() const { return m_target_label; }
- private:
- virtual const char* class_name() const override { return "ContinueStatement"; }
- FlyString m_target_label;
- };
- class DebuggerStatement final : public Statement {
- public:
- DebuggerStatement() { }
- virtual Value execute(Interpreter&, GlobalObject&) const override;
- private:
- virtual const char* class_name() const override { return "DebuggerStatement"; }
- };
- }
|