| // Copyright 2018 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_TORQUE_AST_H_ |
| #define V8_TORQUE_AST_H_ |
| |
| #include <iostream> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "src/base/optional.h" |
| #include "src/torque/source-positions.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace torque { |
| |
| #define AST_EXPRESSION_NODE_KIND_LIST(V) \ |
| V(CallExpression) \ |
| V(StructExpression) \ |
| V(LogicalOrExpression) \ |
| V(LogicalAndExpression) \ |
| V(ConditionalExpression) \ |
| V(IdentifierExpression) \ |
| V(StringLiteralExpression) \ |
| V(NumberLiteralExpression) \ |
| V(FieldAccessExpression) \ |
| V(ElementAccessExpression) \ |
| V(AssignmentExpression) \ |
| V(IncrementDecrementExpression) \ |
| V(AssumeTypeImpossibleExpression) |
| |
| #define AST_TYPE_EXPRESSION_NODE_KIND_LIST(V) \ |
| V(BasicTypeExpression) \ |
| V(FunctionTypeExpression) \ |
| V(UnionTypeExpression) |
| |
| #define AST_STATEMENT_NODE_KIND_LIST(V) \ |
| V(BlockStatement) \ |
| V(ExpressionStatement) \ |
| V(IfStatement) \ |
| V(WhileStatement) \ |
| V(ForLoopStatement) \ |
| V(ForOfLoopStatement) \ |
| V(BreakStatement) \ |
| V(ContinueStatement) \ |
| V(ReturnStatement) \ |
| V(DebugStatement) \ |
| V(AssertStatement) \ |
| V(TailCallStatement) \ |
| V(VarDeclarationStatement) \ |
| V(GotoStatement) \ |
| V(TryLabelStatement) |
| |
| #define AST_DECLARATION_NODE_KIND_LIST(V) \ |
| V(TypeDeclaration) \ |
| V(TypeAliasDeclaration) \ |
| V(StandardDeclaration) \ |
| V(GenericDeclaration) \ |
| V(SpecializationDeclaration) \ |
| V(ExternConstDeclaration) \ |
| V(StructDeclaration) \ |
| V(DefaultModuleDeclaration) \ |
| V(ExplicitModuleDeclaration) \ |
| V(ConstDeclaration) |
| |
| #define AST_CALLABLE_NODE_KIND_LIST(V) \ |
| V(TorqueMacroDeclaration) \ |
| V(TorqueBuiltinDeclaration) \ |
| V(ExternalMacroDeclaration) \ |
| V(ExternalBuiltinDeclaration) \ |
| V(ExternalRuntimeDeclaration) |
| |
| #define AST_NODE_KIND_LIST(V) \ |
| AST_EXPRESSION_NODE_KIND_LIST(V) \ |
| AST_TYPE_EXPRESSION_NODE_KIND_LIST(V) \ |
| AST_STATEMENT_NODE_KIND_LIST(V) \ |
| AST_DECLARATION_NODE_KIND_LIST(V) \ |
| AST_CALLABLE_NODE_KIND_LIST(V) \ |
| V(LabelBlock) |
| |
| struct AstNode { |
| public: |
| enum class Kind { |
| #define ENUM_ITEM(name) k##name, |
| AST_NODE_KIND_LIST(ENUM_ITEM) |
| #undef ENUM_ITEM |
| }; |
| |
| AstNode(Kind kind, SourcePosition pos) : kind(kind), pos(pos) {} |
| virtual ~AstNode() {} |
| |
| const Kind kind; |
| SourcePosition pos; |
| }; |
| |
| struct AstNodeClassCheck { |
| template <class T> |
| static bool IsInstanceOf(AstNode* node); |
| }; |
| |
| // Boilerplate for most derived classes. |
| #define DEFINE_AST_NODE_LEAF_BOILERPLATE(T) \ |
| static const Kind kKind = Kind::k##T; \ |
| static T* cast(AstNode* node) { \ |
| if (node->kind != kKind) return nullptr; \ |
| return static_cast<T*>(node); \ |
| } \ |
| static T* DynamicCast(AstNode* node) { \ |
| if (!node) return nullptr; \ |
| if (!AstNodeClassCheck::IsInstanceOf<T>(node)) return nullptr; \ |
| return static_cast<T*>(node); \ |
| } |
| |
| // Boilerplate for classes with subclasses. |
| #define DEFINE_AST_NODE_INNER_BOILERPLATE(T) \ |
| static T* cast(AstNode* node) { \ |
| DCHECK(AstNodeClassCheck::IsInstanceOf<T>(node)); \ |
| return static_cast<T*>(node); \ |
| } \ |
| static T* DynamicCast(AstNode* node) { \ |
| if (!node) return nullptr; \ |
| if (!AstNodeClassCheck::IsInstanceOf<T>(node)) return nullptr; \ |
| return static_cast<T*>(node); \ |
| } |
| |
| struct Expression : AstNode { |
| Expression(Kind kind, SourcePosition pos) : AstNode(kind, pos) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(Expression) |
| }; |
| |
| struct LocationExpression : Expression { |
| LocationExpression(Kind kind, SourcePosition pos) : Expression(kind, pos) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(LocationExpression) |
| }; |
| |
| struct TypeExpression : AstNode { |
| TypeExpression(Kind kind, SourcePosition pos) : AstNode(kind, pos) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(TypeExpression) |
| }; |
| |
| struct Declaration : AstNode { |
| Declaration(Kind kind, SourcePosition pos) : AstNode(kind, pos) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(Declaration) |
| }; |
| |
| struct Statement : AstNode { |
| Statement(Kind kind, SourcePosition pos) : AstNode(kind, pos) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(Statement) |
| }; |
| |
| class Module; |
| |
| struct ModuleDeclaration : Declaration { |
| ModuleDeclaration(AstNode::Kind kind, SourcePosition pos, |
| std::vector<Declaration*> declarations) |
| : Declaration(kind, pos), |
| module(nullptr), |
| declarations(std::move(declarations)) {} |
| virtual bool IsDefault() const = 0; |
| // virtual std::string GetName() const = 0; |
| void SetModule(Module* m) { module = m; } |
| Module* GetModule() const { return module; } |
| Module* module; |
| std::vector<Declaration*> declarations; |
| }; |
| |
| struct DefaultModuleDeclaration : ModuleDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(DefaultModuleDeclaration) |
| DefaultModuleDeclaration(SourcePosition pos, |
| std::vector<Declaration*> declarations) |
| : ModuleDeclaration(kKind, pos, declarations) {} |
| bool IsDefault() const override { return true; } |
| }; |
| |
| struct ExplicitModuleDeclaration : ModuleDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExplicitModuleDeclaration) |
| ExplicitModuleDeclaration(SourcePosition pos, std::string name, |
| std::vector<Declaration*> declarations) |
| : ModuleDeclaration(kKind, pos, declarations), name(std::move(name)) {} |
| bool IsDefault() const override { return false; } |
| std::string name; |
| }; |
| |
| class Ast { |
| public: |
| Ast() : default_module_{SourcePosition{CurrentSourceFile::Get(), 0, 0}, {}} {} |
| |
| std::vector<Declaration*>& declarations() { |
| return default_module_.declarations; |
| } |
| const std::vector<Declaration*>& declarations() const { |
| return default_module_.declarations; |
| } |
| template <class T> |
| T* AddNode(std::unique_ptr<T> node) { |
| T* result = node.get(); |
| nodes_.push_back(std::move(node)); |
| return result; |
| } |
| DefaultModuleDeclaration* default_module() { return &default_module_; } |
| |
| private: |
| DefaultModuleDeclaration default_module_; |
| std::vector<std::unique_ptr<AstNode>> nodes_; |
| }; |
| |
| struct IdentifierExpression : LocationExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(IdentifierExpression) |
| IdentifierExpression(SourcePosition pos, std::string name, |
| std::vector<TypeExpression*> args = {}) |
| : LocationExpression(kKind, pos), |
| name(std::move(name)), |
| generic_arguments(std::move(args)) {} |
| std::string name; |
| std::vector<TypeExpression*> generic_arguments; |
| }; |
| |
| struct CallExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(CallExpression) |
| CallExpression(SourcePosition pos, std::string callee, bool is_operator, |
| std::vector<TypeExpression*> generic_arguments, |
| std::vector<Expression*> arguments, |
| std::vector<std::string> labels) |
| : Expression(kKind, pos), |
| callee(pos, std::move(callee), std::move(generic_arguments)), |
| is_operator(is_operator), |
| arguments(std::move(arguments)), |
| labels(labels) {} |
| IdentifierExpression callee; |
| bool is_operator; |
| std::vector<Expression*> arguments; |
| std::vector<std::string> labels; |
| }; |
| |
| struct StructExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(StructExpression) |
| StructExpression(SourcePosition pos, std::string name, |
| std::vector<Expression*> expressions) |
| : Expression(kKind, pos), |
| name(name), |
| expressions(std::move(expressions)) {} |
| std::string name; |
| std::vector<Expression*> expressions; |
| }; |
| |
| struct LogicalOrExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(LogicalOrExpression) |
| LogicalOrExpression(SourcePosition pos, Expression* left, Expression* right) |
| : Expression(kKind, pos), left(left), right(right) {} |
| Expression* left; |
| Expression* right; |
| }; |
| |
| struct LogicalAndExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(LogicalAndExpression) |
| LogicalAndExpression(SourcePosition pos, Expression* left, Expression* right) |
| : Expression(kKind, pos), left(left), right(right) {} |
| Expression* left; |
| Expression* right; |
| }; |
| |
| struct ConditionalExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ConditionalExpression) |
| ConditionalExpression(SourcePosition pos, Expression* condition, |
| Expression* if_true, Expression* if_false) |
| : Expression(kKind, pos), |
| condition(condition), |
| if_true(if_true), |
| if_false(if_false) {} |
| Expression* condition; |
| Expression* if_true; |
| Expression* if_false; |
| }; |
| |
| struct StringLiteralExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(StringLiteralExpression) |
| StringLiteralExpression(SourcePosition pos, std::string literal) |
| : Expression(kKind, pos), literal(std::move(literal)) {} |
| std::string literal; |
| }; |
| |
| struct NumberLiteralExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(NumberLiteralExpression) |
| NumberLiteralExpression(SourcePosition pos, std::string name) |
| : Expression(kKind, pos), number(std::move(name)) {} |
| std::string number; |
| }; |
| |
| struct ElementAccessExpression : LocationExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ElementAccessExpression) |
| ElementAccessExpression(SourcePosition pos, Expression* array, |
| Expression* index) |
| : LocationExpression(kKind, pos), array(array), index(index) {} |
| Expression* array; |
| Expression* index; |
| }; |
| |
| struct FieldAccessExpression : LocationExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(FieldAccessExpression) |
| FieldAccessExpression(SourcePosition pos, Expression* object, |
| std::string field) |
| : LocationExpression(kKind, pos), |
| object(object), |
| field(std::move(field)) {} |
| Expression* object; |
| std::string field; |
| }; |
| |
| struct AssignmentExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(AssignmentExpression) |
| AssignmentExpression(SourcePosition pos, LocationExpression* location, |
| base::Optional<std::string> op, Expression* value) |
| : Expression(kKind, pos), |
| location(location), |
| op(std::move(op)), |
| value(value) {} |
| LocationExpression* location; |
| base::Optional<std::string> op; |
| Expression* value; |
| }; |
| |
| enum class IncrementDecrementOperator { kIncrement, kDecrement }; |
| |
| struct IncrementDecrementExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(IncrementDecrementExpression) |
| IncrementDecrementExpression(SourcePosition pos, LocationExpression* location, |
| IncrementDecrementOperator op, bool postfix) |
| : Expression(kKind, pos), location(location), op(op), postfix(postfix) {} |
| LocationExpression* location; |
| IncrementDecrementOperator op; |
| bool postfix; |
| }; |
| |
| // This expression is only used in the desugaring of typeswitch, and it allows |
| // to bake in the static information that certain types are impossible at a |
| // certain position in the control flow. |
| // The result type is the type of {expression} minus the provided type. |
| struct AssumeTypeImpossibleExpression : Expression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(AssumeTypeImpossibleExpression) |
| AssumeTypeImpossibleExpression(SourcePosition pos, |
| TypeExpression* excluded_type, |
| Expression* expression) |
| : Expression(kKind, pos), |
| excluded_type(excluded_type), |
| expression(expression) {} |
| TypeExpression* excluded_type; |
| Expression* expression; |
| }; |
| |
| struct ParameterList { |
| std::vector<std::string> names; |
| std::vector<TypeExpression*> types; |
| bool has_varargs; |
| std::string arguments_variable; |
| |
| static ParameterList Empty() { return ParameterList{{}, {}, false, ""}; } |
| }; |
| |
| struct BasicTypeExpression : TypeExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(BasicTypeExpression) |
| BasicTypeExpression(SourcePosition pos, bool is_constexpr, std::string name) |
| : TypeExpression(kKind, pos), is_constexpr(is_constexpr), name(name) {} |
| bool is_constexpr; |
| std::string name; |
| }; |
| |
| struct FunctionTypeExpression : TypeExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(FunctionTypeExpression) |
| FunctionTypeExpression(SourcePosition pos, |
| std::vector<TypeExpression*> parameters, |
| TypeExpression* return_type) |
| : TypeExpression(kKind, pos), |
| parameters(parameters), |
| return_type(return_type) {} |
| std::vector<TypeExpression*> parameters; |
| TypeExpression* return_type; |
| }; |
| |
| struct UnionTypeExpression : TypeExpression { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(UnionTypeExpression) |
| UnionTypeExpression(SourcePosition pos, TypeExpression* a, TypeExpression* b) |
| : TypeExpression(kKind, pos), a(a), b(b) {} |
| TypeExpression* a; |
| TypeExpression* b; |
| }; |
| |
| struct ExpressionStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExpressionStatement) |
| ExpressionStatement(SourcePosition pos, Expression* expression) |
| : Statement(kKind, pos), expression(expression) {} |
| Expression* expression; |
| }; |
| |
| struct IfStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(IfStatement) |
| IfStatement(SourcePosition pos, bool is_constexpr, Expression* condition, |
| Statement* if_true, base::Optional<Statement*> if_false) |
| : Statement(kKind, pos), |
| condition(condition), |
| is_constexpr(is_constexpr), |
| if_true(if_true), |
| if_false(if_false) {} |
| Expression* condition; |
| bool is_constexpr; |
| Statement* if_true; |
| base::Optional<Statement*> if_false; |
| }; |
| |
| struct WhileStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(WhileStatement) |
| WhileStatement(SourcePosition pos, Expression* condition, Statement* body) |
| : Statement(kKind, pos), condition(condition), body(body) {} |
| Expression* condition; |
| Statement* body; |
| }; |
| |
| struct ReturnStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ReturnStatement) |
| ReturnStatement(SourcePosition pos, base::Optional<Expression*> value) |
| : Statement(kKind, pos), value(value) {} |
| base::Optional<Expression*> value; |
| }; |
| |
| struct DebugStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(DebugStatement) |
| DebugStatement(SourcePosition pos, const std::string& reason, |
| bool never_continues) |
| : Statement(kKind, pos), |
| reason(reason), |
| never_continues(never_continues) {} |
| std::string reason; |
| bool never_continues; |
| }; |
| |
| struct AssertStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(AssertStatement) |
| AssertStatement(SourcePosition pos, bool debug_only, Expression* expression, |
| std::string source) |
| : Statement(kKind, pos), |
| debug_only(debug_only), |
| expression(expression), |
| source(std::move(source)) {} |
| bool debug_only; |
| Expression* expression; |
| std::string source; |
| }; |
| |
| struct TailCallStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TailCallStatement) |
| TailCallStatement(SourcePosition pos, CallExpression* call) |
| : Statement(kKind, pos), call(call) {} |
| CallExpression* call; |
| }; |
| |
| struct VarDeclarationStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(VarDeclarationStatement) |
| VarDeclarationStatement( |
| SourcePosition pos, bool const_qualified, std::string name, |
| base::Optional<TypeExpression*> type, |
| base::Optional<Expression*> initializer = base::nullopt) |
| : Statement(kKind, pos), |
| const_qualified(const_qualified), |
| name(std::move(name)), |
| type(type), |
| initializer(initializer) {} |
| bool const_qualified; |
| std::string name; |
| base::Optional<TypeExpression*> type; |
| base::Optional<Expression*> initializer; |
| }; |
| |
| struct BreakStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(BreakStatement) |
| explicit BreakStatement(SourcePosition pos) : Statement(kKind, pos) {} |
| }; |
| |
| struct ContinueStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ContinueStatement) |
| explicit ContinueStatement(SourcePosition pos) : Statement(kKind, pos) {} |
| }; |
| |
| struct GotoStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(GotoStatement) |
| GotoStatement(SourcePosition pos, std::string label, |
| const std::vector<Expression*>& arguments) |
| : Statement(kKind, pos), |
| label(std::move(label)), |
| arguments(std::move(arguments)) {} |
| std::string label; |
| std::vector<Expression*> arguments; |
| }; |
| |
| struct ForLoopStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ForLoopStatement) |
| ForLoopStatement(SourcePosition pos, base::Optional<Statement*> declaration, |
| base::Optional<Expression*> test, |
| base::Optional<Expression*> action, Statement* body) |
| : Statement(kKind, pos), |
| var_declaration(), |
| test(std::move(test)), |
| action(std::move(action)), |
| body(std::move(body)) { |
| if (declaration) |
| var_declaration = VarDeclarationStatement::cast(*declaration); |
| } |
| base::Optional<VarDeclarationStatement*> var_declaration; |
| base::Optional<Expression*> test; |
| base::Optional<Expression*> action; |
| Statement* body; |
| }; |
| |
| struct RangeExpression { |
| base::Optional<Expression*> begin; |
| base::Optional<Expression*> end; |
| }; |
| |
| struct ForOfLoopStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ForOfLoopStatement) |
| ForOfLoopStatement(SourcePosition pos, Statement* decl, Expression* iterable, |
| base::Optional<RangeExpression> range, Statement* body) |
| : Statement(kKind, pos), |
| var_declaration(VarDeclarationStatement::cast(decl)), |
| iterable(iterable), |
| body(body) { |
| if (range) { |
| begin = range->begin; |
| end = range->end; |
| } |
| } |
| VarDeclarationStatement* var_declaration; |
| Expression* iterable; |
| base::Optional<Expression*> begin; |
| base::Optional<Expression*> end; |
| Statement* body; |
| }; |
| |
| struct LabelBlock : AstNode { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(LabelBlock) |
| LabelBlock(SourcePosition pos, const std::string& label, |
| const ParameterList& parameters, Statement* body) |
| : AstNode(kKind, pos), |
| label(std::move(label)), |
| parameters(parameters), |
| body(std::move(body)) {} |
| std::string label; |
| ParameterList parameters; |
| Statement* body; |
| }; |
| |
| struct TryLabelStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TryLabelStatement) |
| TryLabelStatement(SourcePosition pos, Statement* try_block, |
| std::vector<LabelBlock*> label_blocks) |
| : Statement(kKind, pos), |
| try_block(try_block), |
| label_blocks(std::move(label_blocks)) {} |
| Statement* try_block; |
| std::vector<LabelBlock*> label_blocks; |
| }; |
| |
| struct BlockStatement : Statement { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(BlockStatement) |
| explicit BlockStatement(SourcePosition pos, bool deferred = false, |
| std::vector<Statement*> statements = {}) |
| : Statement(kKind, pos), |
| deferred(deferred), |
| statements(std::move(statements)) {} |
| bool deferred; |
| std::vector<Statement*> statements; |
| }; |
| |
| struct TypeDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TypeDeclaration) |
| TypeDeclaration(SourcePosition pos, std::string name, |
| base::Optional<std::string> extends, |
| base::Optional<std::string> generates, |
| base::Optional<std::string> constexpr_generates) |
| : Declaration(kKind, pos), |
| name(std::move(name)), |
| extends(std::move(extends)), |
| generates(std::move(generates)), |
| constexpr_generates(std::move(constexpr_generates)) {} |
| std::string name; |
| base::Optional<std::string> extends; |
| base::Optional<std::string> generates; |
| base::Optional<std::string> constexpr_generates; |
| }; |
| |
| struct TypeAliasDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TypeAliasDeclaration) |
| TypeAliasDeclaration(SourcePosition pos, std::string name, |
| TypeExpression* type) |
| : Declaration(kKind, pos), name(std::move(name)), type(type) {} |
| std::string name; |
| TypeExpression* type; |
| }; |
| |
| struct NameAndTypeExpression { |
| std::string name; |
| TypeExpression* type; |
| }; |
| |
| struct LabelAndTypes { |
| std::string name; |
| std::vector<TypeExpression*> types; |
| }; |
| |
| typedef std::vector<LabelAndTypes> LabelAndTypesVector; |
| |
| struct CallableNodeSignature { |
| ParameterList parameters; |
| TypeExpression* return_type; |
| LabelAndTypesVector labels; |
| }; |
| |
| struct CallableNode : AstNode { |
| CallableNode(AstNode::Kind kind, SourcePosition pos, std::string name, |
| ParameterList parameters, TypeExpression* return_type, |
| const LabelAndTypesVector& labels) |
| : AstNode(kind, pos), |
| name(std::move(name)), |
| signature(new CallableNodeSignature{parameters, return_type, labels}) {} |
| DEFINE_AST_NODE_INNER_BOILERPLATE(CallableNode) |
| std::string name; |
| std::unique_ptr<CallableNodeSignature> signature; |
| }; |
| |
| struct MacroDeclaration : CallableNode { |
| DEFINE_AST_NODE_INNER_BOILERPLATE(MacroDeclaration) |
| MacroDeclaration(AstNode::Kind kind, SourcePosition pos, std::string name, |
| base::Optional<std::string> op, ParameterList parameters, |
| TypeExpression* return_type, |
| const LabelAndTypesVector& labels) |
| : CallableNode(kind, pos, name, parameters, return_type, labels), |
| op(std::move(op)) {} |
| base::Optional<std::string> op; |
| }; |
| |
| struct ExternalMacroDeclaration : MacroDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalMacroDeclaration) |
| ExternalMacroDeclaration(SourcePosition pos, std::string name, |
| base::Optional<std::string> op, |
| ParameterList parameters, |
| TypeExpression* return_type, |
| const LabelAndTypesVector& labels) |
| : MacroDeclaration(kKind, pos, name, op, parameters, return_type, |
| labels) {} |
| }; |
| |
| struct TorqueMacroDeclaration : MacroDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TorqueMacroDeclaration) |
| TorqueMacroDeclaration(SourcePosition pos, std::string name, |
| base::Optional<std::string> op, |
| ParameterList parameters, TypeExpression* return_type, |
| const LabelAndTypesVector& labels) |
| : MacroDeclaration(kKind, pos, name, op, parameters, return_type, |
| labels) {} |
| }; |
| |
| struct BuiltinDeclaration : CallableNode { |
| BuiltinDeclaration(AstNode::Kind kind, SourcePosition pos, |
| bool javascript_linkage, std::string name, |
| ParameterList parameters, TypeExpression* return_type) |
| : CallableNode(kind, pos, name, parameters, return_type, {}), |
| javascript_linkage(javascript_linkage) {} |
| bool javascript_linkage; |
| }; |
| |
| struct ExternalBuiltinDeclaration : BuiltinDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalBuiltinDeclaration) |
| ExternalBuiltinDeclaration(SourcePosition pos, bool javascript_linkage, |
| std::string name, ParameterList parameters, |
| TypeExpression* return_type) |
| : BuiltinDeclaration(kKind, pos, javascript_linkage, name, parameters, |
| return_type) {} |
| }; |
| |
| struct TorqueBuiltinDeclaration : BuiltinDeclaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(TorqueBuiltinDeclaration) |
| TorqueBuiltinDeclaration(SourcePosition pos, bool javascript_linkage, |
| std::string name, ParameterList parameters, |
| TypeExpression* return_type) |
| : BuiltinDeclaration(kKind, pos, javascript_linkage, name, parameters, |
| return_type) {} |
| }; |
| |
| struct ExternalRuntimeDeclaration : CallableNode { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternalRuntimeDeclaration) |
| ExternalRuntimeDeclaration(SourcePosition pos, std::string name, |
| ParameterList parameters, |
| TypeExpression* return_type) |
| : CallableNode(kKind, pos, name, parameters, return_type, {}) {} |
| }; |
| |
| struct ConstDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ConstDeclaration) |
| ConstDeclaration(SourcePosition pos, std::string name, TypeExpression* type, |
| Expression* expression) |
| : Declaration(kKind, pos), |
| name(std::move(name)), |
| type(type), |
| expression(expression) {} |
| std::string name; |
| TypeExpression* type; |
| Expression* expression; |
| }; |
| |
| struct StandardDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(StandardDeclaration) |
| StandardDeclaration(SourcePosition pos, CallableNode* callable, |
| Statement* body) |
| : Declaration(kKind, pos), callable(callable), body(body) {} |
| CallableNode* callable; |
| Statement* body; |
| }; |
| |
| struct GenericDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(GenericDeclaration) |
| GenericDeclaration(SourcePosition pos, CallableNode* callable, |
| std::vector<std::string> generic_parameters, |
| base::Optional<Statement*> body = base::nullopt) |
| : Declaration(kKind, pos), |
| callable(callable), |
| generic_parameters(std::move(generic_parameters)), |
| body(body) {} |
| CallableNode* callable; |
| std::vector<std::string> generic_parameters; |
| base::Optional<Statement*> body; |
| }; |
| |
| struct SpecializationDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(SpecializationDeclaration) |
| SpecializationDeclaration(SourcePosition pos, std::string name, |
| std::vector<TypeExpression*> generic_parameters, |
| ParameterList parameters, |
| TypeExpression* return_type, |
| LabelAndTypesVector labels, Statement* b) |
| : Declaration(kKind, pos), |
| name(std::move(name)), |
| external(false), |
| generic_parameters(generic_parameters), |
| signature(new CallableNodeSignature{parameters, return_type, labels}), |
| body(b) {} |
| std::string name; |
| bool external; |
| std::vector<TypeExpression*> generic_parameters; |
| std::unique_ptr<CallableNodeSignature> signature; |
| Statement* body; |
| }; |
| |
| struct ExternConstDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(ExternConstDeclaration) |
| ExternConstDeclaration(SourcePosition pos, std::string name, |
| TypeExpression* type, std::string literal) |
| : Declaration(kKind, pos), |
| name(std::move(name)), |
| type(type), |
| literal(std::move(literal)) {} |
| std::string name; |
| TypeExpression* type; |
| std::string literal; |
| }; |
| |
| struct StructDeclaration : Declaration { |
| DEFINE_AST_NODE_LEAF_BOILERPLATE(StructDeclaration) |
| StructDeclaration(SourcePosition pos, std::string name, |
| std::vector<NameAndTypeExpression> fields) |
| : Declaration(kKind, pos), |
| name(std::move(name)), |
| fields(std::move(fields)) {} |
| std::string name; |
| std::vector<NameAndTypeExpression> fields; |
| }; |
| |
| #define ENUM_ITEM(name) \ |
| case AstNode::Kind::k##name: \ |
| return std::is_base_of<T, name>::value; \ |
| break; |
| |
| template <class T> |
| bool AstNodeClassCheck::IsInstanceOf(AstNode* node) { |
| switch (node->kind) { |
| AST_NODE_KIND_LIST(ENUM_ITEM) |
| default: |
| UNIMPLEMENTED(); |
| } |
| return true; |
| } |
| |
| #undef ENUM_ITEM |
| |
| } // namespace torque |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_TORQUE_AST_H_ |