zlotowek/forklang
1
0
Fork 0
forked from KPGPMC/furlang
Code Pull Requests Activity

refactor(AST): node location

Browse Source 
Add location function to node and introduce a new abstract_node class.

Refs: #1
This commit is contained in:
Aleksander Krajewski
2026-06-03 13:47:01 +02:00
parent 9b92c06d87
commit 52537e0955
8 changed files with 162 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files
furc/src/ast.cpp
+16 -17
View File
@@ -13,7 +13,7 @@ std::ostream& operator<<(std::ostream& os, const error& error) {
}
bool literal_node::equal(const node& rhs) const {
return literal_type() == reinterpret_cast<const literal_node&>(rhs).literal_type();
return literal_type() == dynamic_cast<const literal_node&>(rhs).literal_type();
}
void string_literal_node::accept(visitor& visitor) const {
@@ -26,7 +26,7 @@ std::ostream& string_literal_node::print(std::ostream& os) const {
}
bool string_literal_node::equal(const node& rhs) const {
return literal_node::equal(rhs) && m_value == reinterpret_cast<const string_literal_node&>(rhs).m_value;
return literal_node::equal(rhs) && m_value == dynamic_cast<const string_literal_node&>(rhs).m_value;
}
void integer_literal_node::accept(visitor& visitor) const {
@@ -39,11 +39,11 @@ std::ostream& integer_literal_node::print(std::ostream& os) const {
}
bool integer_literal_node::equal(const node& rhs) const {
return literal_node::equal(rhs) && m_value == reinterpret_cast<const integer_literal_node&>(rhs).m_value;
return literal_node::equal(rhs) && m_value == dynamic_cast<const integer_literal_node&>(rhs).m_value;
}
bool expression_node::equal(const node& rhs) const {
return expression_type() == reinterpret_cast<const expression_node&>(rhs).expression_type();
return expression_type() == dynamic_cast<const expression_node&>(rhs).expression_type();
}
void var_read_expression_node::accept(visitor& visitor) const {
@@ -56,7 +56,7 @@ std::ostream& var_read_expression_node::print(std::ostream& os) const {
}
bool var_read_expression_node::equal(const node& rhsNode) const {
const auto& rhs = reinterpret_cast<const var_read_expression_node&>(rhsNode);
const auto& rhs = dynamic_cast<const var_read_expression_node&>(rhsNode);
return expression_node::equal(rhsNode) && m_name == rhs.m_name;
}
@@ -90,7 +90,7 @@ std::ostream& unaryop_expression_node::print(std::ostream& os) const {
}
bool unaryop_expression_node::equal(const node& rhsNode) const {
const auto& rhs = reinterpret_cast<const unaryop_expression_node&>(rhsNode);
const auto& rhs = dynamic_cast<const unaryop_expression_node&>(rhsNode);
return expression_node::equal(rhsNode) && m_type == rhs.m_type && m_node == rhs.m_node;
}
@@ -122,7 +122,7 @@ std::ostream& binop_expression_node::print(std::ostream& os) const {
}
bool binop_expression_node::equal(const node& rhsNode) const {
const auto& rhs = reinterpret_cast<const binop_expression_node&>(rhsNode);
const auto& rhs = dynamic_cast<const binop_expression_node&>(rhsNode);
return expression_node::equal(rhsNode) && m_type == rhs.m_type && m_lhs == rhs.m_lhs && m_rhs == rhs.m_rhs;
}
@@ -135,12 +135,12 @@ std::ostream& var_assign_expression_node::print(std::ostream& os) const {
}
bool var_assign_expression_node::equal(const node& rhsNode) const {
const auto& rhs = reinterpret_cast<const var_assign_expression_node&>(rhsNode);
const auto& rhs = dynamic_cast<const var_assign_expression_node&>(rhsNode);
return expression_node::equal(rhsNode) && m_compound == rhs.m_compound && m_lhs == rhs.m_lhs && m_rhs == rhs.m_rhs;
}
bool declaration_node::equal(const node& rhs) const {
return declaration_type() == reinterpret_cast<const declaration_node&>(rhs).declaration_type();
return declaration_type() == dynamic_cast<const declaration_node&>(rhs).declaration_type();
}
void function_declaration_node::accept(visitor& visitor) const {
@@ -152,7 +152,7 @@ std::ostream& function_declaration_node::print(std::ostream& os) const {
}
bool function_declaration_node::equal(const node& rhs) const {
return declaration_node::equal(rhs) && p_name == reinterpret_cast<const function_declaration_node&>(rhs).p_name;
return declaration_node::equal(rhs) && p_name == dynamic_cast<const function_declaration_node&>(rhs).p_name;
}
void function_definition_node::accept(visitor& visitor) const {
@@ -171,12 +171,11 @@ std::ostream& function_definition_node::print(std::ostream& os) const {
}
bool function_definition_node::equal(const node& rhs) const {
return function_declaration_node::equal(rhs) &&
m_body == reinterpret_cast<const function_definition_node&>(rhs).m_body;
return function_declaration_node::equal(rhs) && m_body == dynamic_cast<const function_definition_node&>(rhs).m_body;
}
bool statement_node::equal(const node& rhs) const {
return statement_type() == reinterpret_cast<const statement_node&>(rhs).statement_type();
return statement_type() == dynamic_cast<const statement_node&>(rhs).statement_type();
}
void return_statement_node::accept(visitor& visitor) const {
@@ -190,7 +189,7 @@ std::ostream& return_statement_node::print(std::ostream& os) const {
}
bool return_statement_node::equal(const node& rhs) const {
return statement_node::equal(rhs) && m_value == reinterpret_cast<const return_statement_node&>(rhs).m_value;
return statement_node::equal(rhs) && m_value == dynamic_cast<const return_statement_node&>(rhs).m_value;
}
void if_statement_node::accept(visitor& visitor) const {
@@ -205,7 +204,7 @@ std::ostream& if_statement_node::print(std::ostream& os) const {
}
bool if_statement_node::equal(const node& rhsNode) const {
const auto& rhs = reinterpret_cast<const if_statement_node&>(rhsNode);
const auto& rhs = dynamic_cast<const if_statement_node&>(rhsNode);
return statement_node::equal(rhs) && m_cond == rhs.m_cond && m_then == rhs.m_then && m_else == rhs.m_else;
}
@@ -218,7 +217,7 @@ std::ostream& compound_statement_node::print(std::ostream& os) const {
}
bool compound_statement_node::equal(const node& rhs) const {
return statement_node::equal(rhs) && m_body == reinterpret_cast<const compound_statement_node&>(rhs).m_body;
return statement_node::equal(rhs) && m_body == dynamic_cast<const compound_statement_node&>(rhs).m_body;
}
void program_node::accept(visitor& visitor) const {
@@ -240,7 +239,7 @@ std::ostream& program_node::print(std::ostream& os) const {
}
bool program_node::equal(const node& rhs) const {
return m_declarations == reinterpret_cast<const program_node&>(rhs).m_declarations;
return m_declarations == dynamic_cast<const program_node&>(rhs).m_declarations;
}
std::ostream& operator<<(std::ostream& os, const body& body) {
furc/src/front/parser.cpp
+22 -15
View File
@@ -31,7 +31,7 @@ parser::parser(std::string_view filename)
}
ast::program_node_r parser::parse() & {
auto program = m_arena.allocate_shared<ast::program_node>();
auto program = m_arena.allocate_shared<ast::program_node>(location{ m_filename });
while (peek_token().has_value()) {
program->push(std::move(parse_declaration()));
@@ -61,11 +61,11 @@ ast::declaration_node_r parser::parse_declaration() {
case token_t::LBrace: {
ast::body_r body = parse_body();
if (body.has_error()) return ast::declaration_node_r(ast::error{ body.error().location });
return m_arena.allocate_shared<ast::function_definition_node>(*name, std::move(body));
return m_arena.allocate_shared<ast::function_definition_node>(first->location, *name, std::move(body));
}
case token_t::Semicolon: {
m_peekBuffer.clear();
return m_arena.allocate_shared<ast::function_declaration_node>(*name);
return m_arena.allocate_shared<ast::function_declaration_node>(first->location, *name);
}
default: return ast::declaration_node_r(ast::error{ tok->location });
}
@@ -101,13 +101,13 @@ ast::statement_node_r parser::parse_statement() {
auto tok = next_token();
if (peek_token()->type == token_t::Semicolon) {
next_token();
return m_arena.allocate_shared<ast::return_statement_node>();
return m_arena.allocate_shared<ast::return_statement_node>(location);
}
auto value = parse_expression();
auto err = eat_token(token_t::Semicolon);
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
return m_arena.allocate_shared<ast::return_statement_node>(std::move(value));
return m_arena.allocate_shared<ast::return_statement_node>(location, std::move(value));
}
case keyword_token::If: {
auto tok = next_token();
@@ -126,19 +126,20 @@ ast::statement_node_r parser::parse_statement() {
peek_token()->value.keyword == keyword_token::Else) {
next_token();
return m_arena.allocate_shared<ast::if_statement_node>(std::move(cond),
return m_arena.allocate_shared<ast::if_statement_node>(location,
std::move(cond),
std::move(then),
std::move(parse_statement()));
}
return m_arena.allocate_shared<ast::if_statement_node>(std::move(cond), std::move(then));
return m_arena.allocate_shared<ast::if_statement_node>(location, std::move(cond), std::move(then));
}
case keyword_token::None:
case keyword_token::Func:
default: break;
}
}
case token_t::LBrace: return m_arena.allocate_shared<ast::compound_statement_node>(parse_body());
case token_t::LBrace: return m_arena.allocate_shared<ast::compound_statement_node>(location, parse_body());
default: break;
}
@@ -165,12 +166,12 @@ ast::literal_node_r parser::parse_literal() {
case token_t::String: {
auto tok = next_token();
if (tok.has_error()) return ast::literal_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::string_literal_node>((*tok)->string);
return m_arena.allocate_shared<ast::string_literal_node>(tok->location, (*tok)->string);
}
case token_t::Integer: {
auto tok = next_token();
if (tok.has_error()) return ast::literal_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::integer_literal_node>((*tok)->integer);
return m_arena.allocate_shared<ast::integer_literal_node>(tok->location, (*tok)->integer);
}
default: break;
}
@@ -184,7 +185,7 @@ ast::expression_node_r parser::parse_expression_primary() {
case token_t::Identifier: {
auto tok = next_token();
if (tok.has_error()) return ast::expression_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::var_read_expression_node>((*tok)->string);
return m_arena.allocate_shared<ast::var_read_expression_node>(tok->location, (*tok)->string);
}
case token_t::LParen: {
auto tok = next_token();
@@ -230,7 +231,8 @@ ast::expression_node_r parser::parse_expression_unary(std::uint32_t precedence)
expression = parse_expression_unary(current.precedence + 1);
}
result = m_arena.allocate_shared<ast::unaryop_expression_node>(current.type, std::move(expression));
result =
m_arena.allocate_shared<ast::unaryop_expression_node>(token->location, current.type, std::move(expression));
}
if (result == nullptr) return parse_expression_primary();
@@ -341,13 +343,18 @@ ast::expression_node_r parser::parse_expression_rhs(ast::expression_node_r&& ini
switch (current.type) {
case rhsop_info_t::Unaryop:
lhs = m_arena.allocate_shared<ast::unaryop_expression_node>(current.unary, std::move(lhs));
lhs =
m_arena.allocate_shared<ast::unaryop_expression_node>(opToken->location, current.unary, std::move(lhs));
break;
case rhsop_info_t::Binop:
lhs = m_arena.allocate_shared<ast::binop_expression_node>(current.binary, std::move(lhs), std::move(rhs));
lhs = m_arena.allocate_shared<ast::binop_expression_node>(opToken->location,
current.binary,
std::move(lhs),
std::move(rhs));
break;
case rhsop_info_t::Assignment:
lhs = m_arena.allocate_shared<ast::var_assign_expression_node>(current.assignment,
lhs = m_arena.allocate_shared<ast::var_assign_expression_node>(opToken->location,
current.assignment,
std::move(lhs),
std::move(rhs));
break;