KPGPMC/furlang
5
3
Fork 2
Code Issues 11 Pull Requests Actions Packages Projects 3 Releases Wiki Activity

Merge pull request #7 from CHatingPython/remove-handle

Browse Source 
Remove handle
This commit was merged in pull request #7.
This commit is contained in:
Aleksander Krajewski
2026-06-03 14:14:38 +02:00
committed by GitHub
parent d422b80907 d50bfc868f
commit 1b9514c49c
20 changed files with 810 additions and 961 deletions
Download Patch File Download Diff File Expand all files Collapse all files
furc/include/furc/ast/declaration.hpp
+17 -7
View File
@@ -19,7 +19,15 @@ enum class declaration_node_t {
/**
* @brief Declaration AST node interface.
*/
class declaration_node : public statement_node {
class declaration_node : public statement_node, public abstract_node {
public:
/**
* @brief Construct a new declaration AST node.
*
* @param location Node location.
*/
declaration_node(struct location location)
: abstract_node(location) {}
public:
/**
* @brief Returns this node's category.
@@ -53,10 +61,11 @@ public:
/**
* @brief Construct a new function declaration node object from name token.
*
* @param location Node location.
* @param name Name of the function.
*/
function_declaration_node(front::token name)
: p_name(name) {}
function_declaration_node(struct location location, front::token name)
: declaration_node(location), p_name(name) {}
public:
/**
* @brief Returns this node's declaration type.
@@ -92,11 +101,12 @@ public:
/**
* @brief Construct a new function definition node object from name and body.
*
* @param location Node location.
* @param name Name of the function.
* @param body Body of the function.
*/
function_definition_node(front::token name, body_h&& body)
: function_declaration_node(name), m_body(std::move(body)) {}
function_definition_node(struct location location, front::token name, body_r&& body)
: function_declaration_node(location, name), m_body(std::move(body)) {}
public:
/**
* @brief Returns this node's declaration type.
@@ -110,7 +120,7 @@ public:
*
* @return Body of the function.
*/
const body_h& body() const { return m_body; }
const body_r& body() const { return m_body; }
public:
void accept(visitor& visitor) const override;
@@ -118,7 +128,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
body_h m_body;
body_r m_body;
};
} // namespace ast
furc/include/furc/ast/expression.hpp
+57 -31
View File
@@ -21,7 +21,15 @@ enum class expression_node_t {
/**
* @brief Expression AST node.
*/
class expression_node : public statement_node {
class expression_node : public statement_node, public abstract_node {
public:
/**
* @brief Construct a new expression AST node.
*
* @param location Node location.
*/
expression_node(struct location location)
: abstract_node(location) {}
public:
/**
* @brief Returns this node's category.
@@ -51,28 +59,31 @@ protected:
* @brief Var read expression AST node.
*/
class var_read_expression_node final : public expression_node {
public:
using name_type = furlang::result<std::string_view, error>; /**< Name type alias. */
public:
/**
* @brief Construct a new var read expression node object from a name handle.
*
* @param location Node location.
* @param name Handle to the name.
*/
var_read_expression_node(handle<std::string_view>&& name)
: m_name(std::move(name)) {}
var_read_expression_node(struct location location, name_type&& name)
: expression_node(location), m_name(std::move(name)) {}
/**
* @brief Returns the variable's name.
*
* @return Name of the variable.
*/
const handle<std::string_view>& get_name() const { return m_name; }
const name_type& get_name() const { return m_name; }
/**
* @brief Returns the variable's name.
*
* @return Name of the variable.
*/
handle<std::string_view>&& move_name() { return std::move(m_name); }
name_type&& move_name() { return std::move(m_name); }
public:
/**
* @brief Returns this node's expression type.
@@ -87,7 +98,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
handle<std::string_view> m_name;
name_type m_name;
};
/**
@@ -106,22 +117,25 @@ enum class unaryop_expression_node_t {
* @brief Unary operation expression AST node.
*/
class unaryop_expression_node final : public expression_node {
public:
using value_type = std::optional<expression_node_r>; /**< Value type. */
public:
/**
* @brief Construct a new unaryop expression node object from type and expression node handle.
*
* @param location Node location.
* @param type Operation type.
* @param node Handle to the inner expression node.
*/
unaryop_expression_node(unaryop_expression_node_t type, expression_node_h&& node)
: m_type(type), m_node(std::move(node)) {}
unaryop_expression_node(struct location location, unaryop_expression_node_t type, expression_node_r&& node)
: expression_node(location), m_type(type), m_node(std::move(node)) {}
/**
* @brief Sets this node's inner expression.
*
* @param node New node handle.
*/
void set_node(expression_node_h&& node) { m_node = std::move(node); }
void set_node(expression_node_r&& node) { m_node = std::move(node); }
/**
* @brief Returns the type of this node's operation.
@@ -135,21 +149,21 @@ public:
*
* @return The inner expression.
*/
const expression_node_h& get_node() const { return m_node; }
const value_type& get_node() const { return m_node; }
/**
* @brief Returns this node's inner expression.
*
* @return The inner expression.
*/
expression_node_h& get_node() { return m_node; }
value_type& get_node() { return m_node; }
/**
* @brief Moves this node's inner expression.
*
* @return The moved inner expression.
*/
expression_node_h&& move_node() { return std::move(m_node); }
value_type&& move_node() { return std::move(m_node); }
public:
/**
* @brief Returns this node's expression type.
@@ -165,7 +179,7 @@ protected:
bool equal(const node& rhs) const override;
private:
unaryop_expression_node_t m_type;
expression_node_h m_node; /**< The inner expression. */
value_type m_node; /**< The inner expression. */
};
/**
@@ -195,12 +209,16 @@ public:
/**
* @brief Construct a new binary operation expression AST node.
*
* @param location Node location.
* @param type Binary operation type.
* @param lhs Left-hand-side expression.
* @param rhs Right-hand-side expression.
*/
binop_expression_node(binop_expression_node_t type, expression_node_h&& lhs, expression_node_h&& rhs)
: m_type(type), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
binop_expression_node(struct location location,
binop_expression_node_t type,
expression_node_r&& lhs,
expression_node_r&& rhs)
: expression_node(location), m_type(type), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
/**
* @brief Returns this node's binary operation type.
@@ -214,42 +232,42 @@ public:
*
* @return The left-hand-side expression.
*/
const expression_node_h& lhs() const { return m_lhs; };
const expression_node_r& lhs() const { return m_lhs; };
/**
* @brief Returns this node's left-hand-side expression.
*
* @return The left-hand-side expression.
*/
expression_node_h& lhs() { return m_lhs; };
expression_node_r& lhs() { return m_lhs; };
/**
* @brief Moves this node's left-hand-side expression.
*
* @return The moved left-hand-side expression.
*/
expression_node_h&& move_lhs() { return std::move(m_lhs); };
expression_node_r&& move_lhs() { return std::move(m_lhs); };
/**
* @brief Returns this node's right-hand-side expression.
*
* @return The right-hand-side expression.
*/
const expression_node_h& rhs() const { return m_rhs; };
const expression_node_r& rhs() const { return m_rhs; };
/**
* @brief Returns this node's right-hand-side expression.
*
* @return The right-hand-side expression.
*/
expression_node_h& rhs() { return m_rhs; };
expression_node_r& rhs() { return m_rhs; };
/**
* @brief Moves this node's right-hand-side expression.
*
* @return The moved right-hand-side expression.
*/
expression_node_h&& move_rhs() { return std::move(m_rhs); };
expression_node_r&& move_rhs() { return std::move(m_rhs); };
public:
expression_node_t expression_type() const override { return expression_node_t::Binop; }
public:
@@ -260,8 +278,8 @@ protected:
bool equal(const node& rhs) const override;
private:
binop_expression_node_t m_type;
expression_node_h m_lhs;
expression_node_h m_rhs;
expression_node_r m_lhs;
expression_node_r m_rhs;
};
/**
@@ -272,21 +290,29 @@ public:
/**
* @brief Construct a new variable assignment expression AST node.
*
* @param location Node location.
* @param lhs Left-hand-side expression handle.
* @param rhs Right-hand-side expression handle.
*/
var_assign_expression_node(expression_node_h&& lhs, expression_node_h&& rhs)
: m_compound(binop_expression_node_t::None), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
var_assign_expression_node(struct location location, expression_node_r&& lhs, expression_node_r&& rhs)
: expression_node(location),
m_compound(binop_expression_node_t::None),
m_lhs(std::move(lhs)),
m_rhs(std::move(rhs)) {}
/**
* @brief Construct a new compound variable assignment expression AST node.
*
* @param location Node location.
* @param compound Compound operation type.
* @param lhs Left-hand-side expression handle.
* @param rhs Right-hand-side expression handle.
*/
var_assign_expression_node(binop_expression_node_t compound, expression_node_h&& lhs, expression_node_h&& rhs)
: m_compound(compound), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
var_assign_expression_node(struct location location,
binop_expression_node_t compound,
expression_node_r&& lhs,
expression_node_r&& rhs)
: expression_node(location), m_compound(compound), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
/**
* @brief Returns this node's compound operation type.
@@ -300,14 +326,14 @@ public:
*
* @return The left-hand-side expression.
*/
const expression_node_h& lhs() const { return m_lhs; }
const expression_node_r& lhs() const { return m_lhs; }
/**
* @brief Returns this node's right-hand-side expression.
*
* @return The right-hand-side expression.
*/
const expression_node_h& rhs() const { return m_rhs; }
const expression_node_r& rhs() const { return m_rhs; }
public:
/**
* @brief Returns this node's expression type.
@@ -323,8 +349,8 @@ protected:
bool equal(const node& rhs) const override;
private:
binop_expression_node_t m_compound;
expression_node_h m_lhs;
expression_node_h m_rhs;
expression_node_r m_lhs;
expression_node_r m_rhs;
};
} // namespace ast
furc/include/furc/ast/fwd.hpp
+75 -32
View File
@@ -1,9 +1,11 @@
#ifndef FURC_AST_FWD_HPP
#define FURC_AST_FWD_HPP
#include "furc/handle.hpp"
#include "furc/diag.hpp"
#include "furlang/result.hpp"
#include <string>
#include <cstdint>
#include <memory>
#include <vector>
namespace furc {
@@ -13,23 +15,47 @@ namespace furc {
*/
namespace ast {
/**
* @brief AST error.
*/
struct error {
location location; /**< Location of the error. */
/**
* @brief Compares two AST errors for equality.
*
* @param other Error to compare against.
* @return true if the errors are equal.
*/
bool operator==(const error& other) const { return location == other.location; }
/**
* @brief Compares two AST errors for inequality.
*
* @param other Error to compare against.
* @return true if the errors are not equal.
*/
bool operator!=(const error& other) const { return !this->operator==(other); }
/**
* @brief Prints an AST error to output stream.
*
* @param os Output stream.
* @param error AST error to print.
* @return The output stream.
*/
friend std::ostream& operator<<(std::ostream& os, const error& error);
};
class node;
/**
* @brief Alias for handle to node.
* @brief Alias for node result.
*
* @tparam T AST node type.
*/
template <typename T>
using node_handle = handle<T*, std::string>;
class literal_node;
/**
* @brief Alias for handle to literal_node.
* @see literal_node
*/
using literal_node_h = node_handle<literal_node>;
using node_r = furlang::result<std::shared_ptr<T>, error>;
class expression_node;
@@ -37,7 +63,7 @@ class expression_node;
* @brief Alias for handle to expression_node.
* @see expression_node
*/
using expression_node_h = node_handle<expression_node>;
using expression_node_r = node_r<expression_node>;
class declaration_node;
@@ -45,7 +71,7 @@ class declaration_node;
* @brief Alias for handle to declaration_node.
* @see declaration_node
*/
using declaration_node_h = node_handle<declaration_node>;
using declaration_node_r = node_r<declaration_node>;
class statement_node;
@@ -53,7 +79,7 @@ class statement_node;
* @brief Alias for handle to statement_node.
* @see statement_node
*/
using statement_node_h = node_handle<statement_node>;
using statement_node_r = node_r<statement_node>;
class program_node;
@@ -61,23 +87,40 @@ class program_node;
* @brief Alias for handle to program_node.
* @see program_node
*/
using program_node_h = node_handle<program_node>;
using program_node_r = node_r<program_node>;
class string_literal_node;
/**
* @brief Literal node type.
*/
enum class literal_node_t {
String, /**< String literal. */
Integer, /**< Integer literal. */
};
template <typename, literal_node_t>
class literal_node;
/**
* @brief String literal AST node.
*/
using string_literal_node = literal_node<std::string, literal_node_t::String>;
/**
* @brief Alias for handle to string_literal_node.
* @see string_literal_node
*/
using string_literal_node_h = node_handle<string_literal_node>;
using string_literal_node_r = node_r<string_literal_node>;
class integer_literal_node;
/**
* @brief Integer literal AST node.
*/
using integer_literal_node = literal_node<std::uint64_t, literal_node_t::Integer>;
/**
* @brief Alias for handle to integer_literal_node.
* @see integer_literal_node
*/
using integer_literal_node_h = node_handle<integer_literal_node>;
using integer_literal_node_r = node_r<integer_literal_node>;
class var_read_expression_node;
@@ -85,7 +128,7 @@ class var_read_expression_node;
* @brief Alias for handle to var_read_expression_node.
* @see var_read_expression_node
*/
using var_read_expression_node_h = node_handle<var_read_expression_node>;
using var_read_expression_node_r = node_r<var_read_expression_node>;
class unaryop_expression_node;
@@ -93,7 +136,7 @@ class unaryop_expression_node;
* @brief Alias for handle to unaryop_expression_node.
* @see unaryop_expression_node
*/
using unaryop_expression_node_h = node_handle<unaryop_expression_node>;
using unaryop_expression_node_r = node_r<unaryop_expression_node>;
class binop_expression_node;
@@ -101,7 +144,7 @@ class binop_expression_node;
* @brief Alias for handle to binop_expression_node.
* @see binop_expression_node
*/
using binop_expression_node_h = node_handle<binop_expression_node>;
using binop_expression_node_r = node_r<binop_expression_node>;
class var_assign_expression_node;
@@ -109,7 +152,7 @@ class var_assign_expression_node;
* @brief Alias for handle to var_assign_expression_node.
* @see var_assign_expression_node
*/
using var_assign_expression_node_h = node_handle<var_assign_expression_node>;
using var_assign_expression_node_r = node_r<var_assign_expression_node>;
/**
* @brief List of statements.
@@ -128,7 +171,7 @@ struct body {
/**
* @brief List of statements.
*/
std::vector<statement_node_h> statements;
std::vector<statement_node_r> statements;
/**
* @brief Compares two bodies for equality.
@@ -159,10 +202,10 @@ struct body {
};
/**
* @brief Alias for handle to body.
* @brief Alias for body result.
* @see body
*/
using body_h = handle<body>;
using body_r = furlang::result<body, error>;
class function_declaration_node;
@@ -170,7 +213,7 @@ class function_declaration_node;
* @brief Alias for handle to function_declaration_node.
* @see function_declaration_node
*/
using function_declaration_node_h = node_handle<function_declaration_node>;
using function_declaration_node_r = node_r<function_declaration_node>;
class function_definition_node;
@@ -178,7 +221,7 @@ class function_definition_node;
* @brief Alias for handle to function_definition_node.
* @see function_definition_node
*/
using function_definition_node_h = node_handle<function_definition_node>;
using function_definition_node_r = node_r<function_definition_node>;
class return_statement_node;
@@ -186,7 +229,7 @@ class return_statement_node;
* @brief Alias for handle to return_statement_node.
* @see return_statement_node
*/
using return_statement_node_h = node_handle<return_statement_node>;
using return_statement_node_r = node_r<return_statement_node>;
class if_statement_node;
@@ -194,7 +237,7 @@ class if_statement_node;
* @brief Alias for handle to if_statement_node.
* @see if_statement_node
*/
using if_statement_node_h = node_handle<if_statement_node>;
using if_statement_node_r = node_r<if_statement_node>;
class compound_statement_node;
@@ -202,7 +245,7 @@ class compound_statement_node;
* @brief Alias for handle to compound_statement_node.
* @see compound_statement_node
*/
using compound_statement_node_h = node_handle<compound_statement_node>;
using compound_statement_node_r = node_r<compound_statement_node>;
} // namespace ast
} // namespace furc
furc/include/furc/ast/literal.hpp
+54 -83
View File
@@ -1,25 +1,58 @@
// NOLINTBEGIN(portability-template-virtual-member-function)
#ifndef FURC_AST_LITERAL_HPP
#define FURC_AST_LITERAL_HPP
#include "furc/ast/expression.hpp"
#include "furc/ast/node.hpp"
#include "furc/front/token.hpp"
namespace furc {
namespace ast {
/**
* @brief Literal node type.
*/
enum class literal_node_t {
String, /**< String literal. */
Integer, /**< Integer literal. */
};
/**
* @brief Literal AST node.
*/
template <typename ValueType, literal_node_t LiteralType>
class literal_node : public expression_node {
public:
using value_type = std::remove_reference_t<ValueType>; /**< Value type. */
public:
/**
* @brief Construct a new literal AST node.
*
* @param location Node location.
*/
template <typename = std::enable_if_t<std::is_default_constructible_v<ValueType>>>
literal_node(struct location location)
: expression_node(location) {}
/**
* @brief Construct a new literal AST node.
*
* @param location Node location.
* @param value Node value to copy.
*/
literal_node(struct location location, const value_type& value)
: expression_node(location), p_value(value) {}
/**
* @brief Construct a new literal AST node.
*
* @param location Node location.
* @param value Node value to move.
*/
literal_node(struct location location, value_type&& value)
: expression_node(location), p_value(std::move(value)) {}
/**
* @brief Construct a new literal AST node.
*
* @param location Node location.
* @param args Arguments to call value constructor with.
*/
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<ValueType, Args...>>>
literal_node(struct location location, Args&&... args)
: expression_node(location), p_value(std::forward<Args>(args)...) {}
public:
/**
* @brief Returns this node's category.
@@ -40,92 +73,30 @@ public:
*
* @return The literal type.
*/
virtual literal_node_t literal_type() const = 0;
protected:
bool equal(const node& rhs) const override;
};
/**
* @brief String literal AST node.
*/
class string_literal_node final : public literal_node {
public:
/**
* @brief Construct a new string literal node object from a handle.
*
* @param value A handle to value.
*/
string_literal_node(handle<std::string_view>&& value)
: m_value(std::move(value)) {}
public:
/**
* @brief Returns this node's literal type.
*
* @return literal_node_t::String.
*/
literal_node_t literal_type() const override { return literal_node_t::String; }
literal_node_t literal_type() const { return LiteralType; }
/**
* @brief Returns this node's value.
*
* @return A handle to the value.
* @return A string view result.
*/
const handle<std::string_view>& value() const { return m_value; }
const value_type& value() const { return p_value; }
public:
void accept(visitor& visitor) const override;
void accept(visitor& visitor) const override { visitor.visit(*this); }
std::ostream& print(std::ostream& os) const override;
std::ostream& print(std::ostream& os) const override { return os << p_value; }
protected:
bool equal(const node& rhs) const override;
private:
handle<std::string_view> m_value;
};
/**
* @brief Integer literal AST node.
*/
class integer_literal_node final : public literal_node {
public:
/**
* @brief Construct a new integer literal node object from a handle.
*
* @param value A handle to the value.
*/
integer_literal_node(handle<front::integer_token>&& value)
: m_value(std::move(value)) {}
public:
/**
* @brief Returns this node's literal type.
*
* @return literal_node_t::Integer.
*/
literal_node_t literal_type() const override { return literal_node_t::Integer; }
/**
* @brief Returns this node's value.
*
* @return A handle to the value.
*/
const handle<front::integer_token>& value() const { return m_value; }
/**
* @brief Compares this node with an integer token for equality.
*
* @param integer Integer token to compare against.
* @return true if the integer token is equal to this node.
*/
bool operator==(front::integer_token integer) const { return m_value == integer; }
public:
void accept(visitor& visitor) const override;
std::ostream& print(std::ostream& os) const override;
bool equal(const node& rhsNode) const override {
const auto& rhs = dynamic_cast<const literal_node&>(rhsNode);
return literal_type() == rhs.literal_type() && p_value == rhs.p_value;
}
protected:
bool equal(const node& rhs) const override;
private:
handle<front::integer_token> m_value;
value_type p_value; /**< Node value. */
};
} // namespace ast
} // namespace furc
#endif // FURC_AST_LITERAL_HPP
// NOLINTEND(portability-template-virtual-member-function)
furc/include/furc/ast/node.hpp
+30
View File
@@ -71,6 +71,14 @@ public:
* @return The node category.
*/
virtual node_t category() const = 0;
/**
* @brief Returns the location of this AST node.
* @see locaiton
*
* @return The location.
*/
virtual location location() const = 0;
public:
/**
* @brief Compares two nodes for equality.
@@ -128,6 +136,28 @@ protected:
virtual bool equal(const node& rhs) const = 0;
};
/**
* @brief An abstract AST node.
* @see node
*
* Implements location().
*/
class abstract_node : public virtual node {
public:
abstract_node(struct location location)
: p_location(location) {}
public:
/**
* @brief Returns the location of this AST node.
* @see locaiton
*
* @return The location.
*/
struct location location() const override { return p_location; }
protected:
struct location p_location; /**< Node location. */
};
} // namespace ast
} // namespace furc
furc/include/furc/ast/program.hpp
+11 -5
View File
@@ -12,9 +12,15 @@ namespace ast {
/**
* @brief Program AST node.
*/
class program_node final : public node {
class program_node final : public abstract_node {
public:
program_node() = default;
/**
* @brief Construct a new program AST node.
*
* @param location Node location.
*/
program_node(struct location location)
: abstract_node(location) {}
node_t category() const override { return node_t::Program; }
public:
@@ -23,14 +29,14 @@ public:
*
* @param declaration Declaration to add.
*/
void push(node_handle<declaration_node>&& declaration) { m_declarations.push_back(std::move(declaration)); }
void push(node_r<declaration_node>&& declaration) { m_declarations.push_back(std::move(declaration)); }
/**
* @brief Returns a list of declarations of this program.
*
* @return The list of this program's declarations.
*/
const std::vector<node_handle<declaration_node>>& declarations() const { return m_declarations; }
const std::vector<node_r<declaration_node>>& declarations() const { return m_declarations; }
public:
void accept(visitor& visitor) const override;
@@ -38,7 +44,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
std::vector<node_handle<declaration_node>> m_declarations;
std::vector<node_r<declaration_node>> m_declarations;
};
} // namespace ast
furc/include/furc/ast/statement.hpp
+38 -23
View File
@@ -3,6 +3,8 @@
#include "furc/ast/node.hpp"
#include <optional>
namespace furc {
namespace ast {
@@ -20,7 +22,7 @@ enum class statement_node_t {
/**
* @brief Statement AST node.
*/
class statement_node : public node {
class statement_node : public virtual node {
public:
/**
* @brief Returns this node's category.
@@ -42,24 +44,31 @@ protected:
/**
* @brief Return statement AST node.
*/
class return_statement_node final : public statement_node {
class return_statement_node final : public statement_node, public abstract_node {
public:
return_statement_node() = default;
using value_type = std::optional<expression_node_r>; /**< Value type. */
public:
/**
* @brief Construct a new return statement AST node.
*/
return_statement_node(struct location location)
: abstract_node(location) {}
/**
* @brief Construct a new return statement AST node.
*
* @param location Node location.
* @param value Return value handle.
*/
return_statement_node(expression_node_h&& value)
: m_value(std::move(value)) {}
return_statement_node(struct location location, expression_node_r&& value)
: abstract_node(location), m_value(std::move(value)) {}
public:
/**
* @brief Returns this node's return value handle.
*
* @return The return value handle.
*/
expression_node_h value() const { return m_value; }
value_type value() const { return m_value; }
public:
/**
* @brief Returns this node's statement type.
@@ -74,53 +83,58 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
expression_node_h m_value; /**< Return value handle. */
value_type m_value; /**< Return value handle. */
};
/**
* @brief If statement AST node.
*/
class if_statement_node final : public statement_node {
class if_statement_node final : public statement_node, public abstract_node {
public:
/**
* @brief Construct a new if statement AST node.
*
* @param location Node location.
* @param cond Condition expression handle.
* @param then Then statement handle.
*/
if_statement_node(expression_node_h&& cond, statement_node_h&& then)
: m_cond(std::move(cond)), m_then(std::move(then)) {}
if_statement_node(struct location location, expression_node_r&& cond, statement_node_r&& then)
: abstract_node(location), m_cond(std::move(cond)), m_then(std::move(then)) {}
/**
* @brief Construct a new if statement AST node.
*
* @param location Node location.
* @param cond Condition expression handle.
* @param then Then statement handle.
* @param elze Else statement handle.
*/
if_statement_node(expression_node_h&& cond, statement_node_h&& then, statement_node_h&& elze)
: m_cond(std::move(cond)), m_then(std::move(then)), m_else(std::move(elze)) {}
if_statement_node(struct location location,
expression_node_r&& cond,
statement_node_r&& then,
statement_node_r&& elze)
: abstract_node(location), m_cond(std::move(cond)), m_then(std::move(then)), m_else(std::move(elze)) {}
public:
/**
* @brief Returns this node's condition expression handle.
*
* @return The condition expression handle.
*/
expression_node_h cond() const { return m_cond; }
expression_node_r cond() const { return m_cond; }
/**
* @brief Returns this node's then statement handle.
*
* @return The then statement handle.
*/
const statement_node_h& then() const { return m_then; }
const statement_node_r& then() const { return m_then; }
/**
* @brief Returns this node's else statement handle.
*
* @return The else statement handle.
*/
const statement_node_h& elze() const { return m_else; }
const std::optional<statement_node_r>& elze() const { return m_else; }
public:
/**
* @brief Returns this node's statement type.
@@ -135,30 +149,31 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
expression_node_h m_cond; /**< The condition expression handle */
statement_node_h m_then; /**< The then statement handle */
statement_node_h m_else; /**< The else statement handle */
expression_node_r m_cond; /**< The condition expression handle */
statement_node_r m_then; /**< The then statement handle */
std::optional<statement_node_r> m_else; /**< The else statement handle */
};
/**
* @brief Compound statement AST node.
*/
class compound_statement_node final : public statement_node {
class compound_statement_node final : public statement_node, public abstract_node {
public:
/**
* @brief Construct a new compound statement AST node.
*
* @param location Node location.
* @param body Body handle.
*/
compound_statement_node(body_h&& body)
: m_body(std::move(body)) {}
compound_statement_node(struct location location, body_r&& body)
: abstract_node(location), m_body(std::move(body)) {}
public:
/**
* @brief Returns this node's body handle.
*
* @return The body handle.
*/
const body_h& body() const { return m_body; }
const body_r& body() const { return m_body; }
public:
/**
* @brief Returns this node's statement type.
@@ -173,7 +188,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
body_h m_body; /**< The body handle. */
body_r m_body; /**< The body handle. */
};
} // namespace ast
furc/include/furc/ast/visitor.hpp
+3 -3
View File
@@ -123,11 +123,11 @@ public:
virtual void visit(const compound_statement_node& node) {}
/**
* @brief Visit a node handle with an error.
* @brief Visit an AST error.
*
* @param handle Node handle.
* @param error AST error.
*/
virtual void visit_error(const node_handle<node>& handle) {}
virtual void visit_error(const ast::error& error) {}
};
} // namespace ast
furc/include/furc/front/lexer.hpp
+1 -1
View File
@@ -43,7 +43,7 @@ public:
*
* @return The token handle.
*/
token_handle<> next_token();
token_r next_token();
/**
* @brief Checks whether the cursor is at the EOF.
furc/include/furc/front/parser.hpp
+16 -17
View File
@@ -54,28 +54,27 @@ public:
*
* @return Handle to an AST node of the program.
*/
ast::program_node_h parse() &;
ast::program_node_r parse() &;
private:
ast::declaration_node_h parse_declaration();
ast::statement_node_h parse_statement();
ast::expression_node_h parse_expression(std::uint32_t precedence = 16);
ast::literal_node_h parse_literal();
ast::declaration_node_r parse_declaration();
ast::statement_node_r parse_statement();
ast::expression_node_r parse_expression(std::uint32_t precedence = 16);
ast::expression_node_h parse_expression_primary();
ast::expression_node_h parse_expression_unary(std::uint32_t precedence);
ast::expression_node_h parse_expression_rhs(ast::expression_node_h&& init, std::uint32_t precedence);
ast::expression_node_r parse_expression_primary();
ast::expression_node_r parse_expression_unary(std::uint32_t precedence);
ast::expression_node_r parse_expression_rhs(ast::expression_node_r&& init, std::uint32_t precedence);
ast::body_h parse_body();
ast::body_r parse_body();
private:
token_handle<> next_token();
const token_handle<>& peek_token();
token_handle<> eat_token(token_t type);
token_r next_token();
const token_r& peek_token();
token_r eat_token(token_t type);
private:
std::string m_filename;
std::string m_content;
lexer m_lexer;
furlang::arena m_arena;
std::vector<token_handle<>> m_peekBuffer;
std::string m_filename;
std::string m_content;
lexer m_lexer;
furlang::arena m_arena;
std::vector<token_r> m_peekBuffer;
};
} // namespace front
furc/include/furc/front/token.hpp
+59 -12
View File
@@ -1,9 +1,11 @@
#ifndef FURC_FRONT_TOKEN_HPP
#define FURC_FRONT_TOKEN_HPP
#include "furc/handle.hpp"
#include "furc/diag.hpp"
#include "furlang/result.hpp"
#include <cassert>
#include <cstdint>
#include <ostream>
#include <string_view>
@@ -173,7 +175,9 @@ using integer_token = std::uint64_t; /**< Integer token. */
* @brief Token.
*/
struct token {
token_t type = token_t::None; /**< Token type. */
location location; /**< Token location. */
token_t type = token_t::None; /**< Token type. */
/**
* @brief Token's value.
*/
@@ -241,35 +245,39 @@ struct token {
/**
* @brief Construct a new null token.
*
* @param location Token's location.
* @param type Token's type.
*/
token(token_t type)
: type(type) {}
token(struct location location, token_t type)
: location(location), type(type) {}
/**
* @brief Construct a new string token.
*
* @param location Token's location.
* @param type Token's type.
* @param value String value.
*/
token(token_t type, std::string_view value)
: type(type), value(value) {}
token(struct location location, token_t type, std::string_view value)
: location(location), type(type), value(value) {}
/**
* @brief Construct a new keyword token.
*
* @param location Token's location.
* @param keyword Keyword value.
*/
token(keyword_token keyword)
: type(token_t::Keyword), value(keyword) {}
token(struct location location, keyword_token keyword)
: location(location), type(token_t::Keyword), value(keyword) {}
/**
* @brief Construct a new integer token.
*
* @param location Token's location.
* @param integer Integer value.
*/
token(integer_token integer)
: type(token_t::Integer), value(integer) {}
token(struct location location, integer_token integer)
: location(location), type(token_t::Integer), value(integer) {}
/**
* @brief Returns pointer to this token's value.
@@ -313,8 +321,47 @@ static inline std::ostream& operator<<(std::ostream& os, const token& token) {
}
}
template <typename Error = std::string>
using token_handle = handle<token, Error>; /**< Alias to handle of token. */
/**
* @brief Token error type
*/
enum class token_error_t {
EndOfFile, /**< End of file */
UnexpectedEof, /**< Unexpected end of file */
UnexpectedCharacter, /**< Unexpected character */
UnexpectedToken, /**< Unexpected character */
IntegerOverflow, /**< Integer overflow */
};
/**
* @brief Token error
*
* For token_r alias.
*/
struct token_error {
location location; /**< Error location. */
token_error_t type; /**< Error type. */
std::string message; /**< Error message. */
/**
* @brief Compares two token errors for equality.
*
* @param rhs Error to compare against.
* @return true if the errors are equal.
*/
bool operator==(const token_error& rhs) const {
return location == rhs.location && type == rhs.type && message == rhs.message;
}
/**
* @brief Compares two token errors for inequality.
*
* @param rhs Error to compare against.
* @return true if the errors are not equal.
*/
bool operator!=(const token_error& rhs) const { return !this->operator==(rhs); }
};
using token_r = furlang::result<token, token_error>; /**< Alias to a token result. */
} // namespace front
} // namespace furc
furc/include/furc/handle.hpp
-287
View File
@@ -1,287 +0,0 @@
#ifndef FURC_HANDLE_HPP
#define FURC_HANDLE_HPP
#include "furc/diag.hpp"
#include "furlang/arena.hpp"
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <type_traits>
namespace furc {
template <typename T, typename Error = std::string, typename = void>
class handle;
template <typename T, typename Error>
class handle<T, Error> {
template <typename, typename, typename>
friend class handle;
friend std::ostream& operator<<(std::ostream& os, const handle& result);
public:
using value_type = std::remove_reference_t<T>;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = T&;
using const_reference = const T&;
public:
handle(location location, value_type&& value)
: m_location(location), m_value(std::move(value)) {}
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
handle(location location, Args&&... args)
: m_location(location), m_value(value_type(std::forward<Args>(args)...)) {}
handle(location location, Error&& error)
: m_location(location), m_error(std::move(error)) {}
template <typename U>
handle(const handle<U, Error>& error)
: m_location(error.location()), m_error(error.error()) {}
~handle() = default;
handle(handle&& other) noexcept
: m_location(other.m_location), m_value(std::move(other.m_value)), m_error(std::move(other.m_error)) {
other.m_value.reset();
}
handle(const handle&) = delete;
handle& operator=(handle&& other) noexcept {
if (this == &other) return *this;
m_location = other.m_location;
m_value = other.m_value;
m_error = std::move(other.m_error);
other.m_value.reset();
return *this;
}
handle& operator=(const handle&) = delete;
public:
location location() const { return m_location; }
bool present() const { return m_value.has_value(); }
bool has_error() const { return !m_value.has_value(); }
value_type move() {
value_type value = std::move(*m_value);
m_value.reset();
return value;
}
Error error() const { return m_error; }
reference operator*() { return m_value.value(); } // NOLINT(bugprone-unchecked-optional-access)
const_reference operator*() const { return m_value.value(); } // NOLINT(bugprone-unchecked-optional-access)
pointer operator->() { return &m_value.value(); } // NOLINT(bugprone-unchecked-optional-access)
const_pointer operator->() const { return &m_value.value(); } // NOLINT(bugprone-unchecked-optional-access)
public:
bool operator==(const handle<T, Error>& rhs) const {
if (present() != rhs.present() || error() != rhs.error()) return false;
if (m_value.has_value() && m_value.value() != rhs.m_value.value()) // NOLINT(bugprone-unchecked-optional-access)
return false;
return true;
}
bool operator==(const T& rhs) const {
return m_value.has_value() && *m_value == rhs; // NOLINT(bugprone-unchecked-optional-access)
}
public:
friend std::ostream& operator<<(std::ostream& os, const handle& result) {
os << result.m_location << ": ";
if (result.m_value.has_value()) {
os << *result.m_value;
} else {
os << "ERROR: " << result.m_error;
}
return os;
}
private:
struct location m_location;
std::optional<value_type> m_value = {};
Error m_error;
};
template <typename T, typename Error>
class handle<T*, Error> {
template <typename, typename, typename>
friend class handle;
friend struct data;
friend std::ostream& operator<<(std::ostream& os, const handle& result);
public:
using value_type = T;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = T&;
using const_reference = const T&;
public:
handle() = default;
template <typename U, typename = std::enable_if_t<std::is_base_of_v<value_type, U>>>
handle(location location, std::shared_ptr<U> value)
: m_data(data(location, std::move(value))) {}
template <typename U,
typename = std::enable_if_t<std::is_base_of_v<value_type, U> || std::is_base_of_v<U, value_type>>>
handle(const handle<U*, Error>& other)
: m_data(data{ other }) {}
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
handle(location location, Args&&... args)
: m_data(data(location, std::forward<Args>(args)...)) {}
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
handle(location location, furlang::arena& arena, Args&&... args)
: m_data(data(location, arena, std::forward<Args>(args)...)) {}
handle(location location, Error&& error)
: m_data(data(location, std::move(error))) {}
template <typename U>
handle(const handle<U, Error>& error)
: m_data(data(error)) {}
~handle() = default;
handle(handle&& other) noexcept
: m_data(std::move(other.m_data)) {}
template <typename U, typename = std::enable_if_t<std::is_base_of_v<value_type, U>>>
handle(handle<U*, Error>&& other) noexcept
: m_data(data{ std::move(other) }) {}
handle(const handle& other)
: m_data(other.m_data) {}
handle& operator=(handle&& other) noexcept {
if (this == &other) return *this;
m_data = std::move(other.m_data);
return *this;
}
handle& operator=(const handle& other) {
if (this == &other) return *this;
m_data = other.m_data;
return *this;
}
public:
location location() const { return m_data->location; }
bool present() const { return m_data.has_value() && m_data->value != nullptr; }
bool has_error() const { return m_data.has_value() && m_data->value == nullptr; }
std::shared_ptr<value_type> shared() const { return m_data->value; } // NOLINT(bugprone-unchecked-optional-access)
Error error() const { return m_data->error; } // NOLINT(bugprone-unchecked-optional-access)
reference operator*() { return *m_data->value; } // NOLINT(bugprone-unchecked-optional-access)
const_reference operator*() const { return *m_data->value; } // NOLINT(bugprone-unchecked-optional-access)
pointer operator->() { return m_data->value.get(); } // NOLINT(bugprone-unchecked-optional-access)
const_pointer operator->() const { return m_data->value.get(); } // NOLINT(bugprone-unchecked-optional-access)
public:
bool operator==(const handle<T*, Error>& rhs) const {
if (present() != rhs.present() || error() != rhs.error()) return false;
if (present() && m_data->value != rhs.m_data->value) return false; // NOLINT(bugprone-unchecked-optional-access)
return true;
}
bool operator==(const value_type& rhs) const {
return present() && *m_data->value == rhs; // NOLINT(bugprone-unchecked-optional-access)
}
public:
friend std::ostream& operator<<(std::ostream& os, const handle& result) {
if (!result.m_data.has_value()) return os << "handle empty";
os << result.m_data->location << ": ";
if (result.m_data->value != nullptr) {
os << *result.m_data->value;
} else {
os << "ERROR: " << result.m_data->error;
}
return os;
}
private:
struct data {
struct location location;
std::shared_ptr<value_type> value = nullptr;
Error error = {};
template <typename U, typename = std::enable_if_t<std::is_base_of_v<value_type, U>>>
data(struct location location, std::shared_ptr<U> value)
: location(location), value(std::move(value)) {}
template <typename U,
typename = std::enable_if_t<std::is_base_of_v<value_type, U> || std::is_base_of_v<U, value_type>>>
data(handle<U*, Error>&& other) // NOLINT
: location(other.m_data->location) { // NOLINT(bugprone-unchecked-optional-access)
if constexpr (std::is_base_of_v<value_type, U>) {
value = std::static_pointer_cast<value_type>(
std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access)
} else {
value = std::dynamic_pointer_cast<value_type>(
std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access)
}
}
template <typename U,
typename = std::enable_if_t<std::is_base_of_v<value_type, U> || std::is_base_of_v<U, value_type>>>
data(const handle<U*, Error>& other)
: location(other.m_data->location) { // NOLINT(bugprone-unchecked-optional-access)
if constexpr (std::is_base_of_v<value_type, U>) {
value = std::static_pointer_cast<value_type>(
std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access)
} else {
value = std::dynamic_pointer_cast<value_type>(
std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access)
}
}
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
data(struct location location, Args&&... args)
: location(location), value(std::make_shared<value_type>(std::forward<Args>(args)...)) {}
template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
data(struct location location, furlang::arena& arena, Args&&... args)
: location(location), value(arena.allocate_shared<value_type>(std::forward<Args>(args)...)) {}
data(struct location location, Error&& error)
: location(location), error(std::move(error)) {}
template <typename U>
data(const handle<U, Error>& error)
: location(error.location()), error(error.error()) {}
~data() = default;
data(data&& other) noexcept
: location(other.location), value(std::move(other.value)), error(std::move(other.error)) {}
data(const data& other)
: location(other.location), value(other.value), error(other.error) {}
data& operator=(data&& other) noexcept {
if (this == &other) return *this;
location = other.location;
value = std::move(other.value);
error = std::move(other.error);
return *this;
}
data& operator=(const data& other) noexcept {
if (this == &other) return *this;
location = other.location;
value = other.value;
error = other.error;
return *this;
}
};
std::optional<data> m_data = {};
};
} // namespace furc
#endif // FURC_HANDLE_HPP
furc/src/ast.cpp
+28 -54
View File
@@ -1,5 +1,5 @@
#include "furc/ast/declaration.hpp"
#include "furc/ast/literal.hpp"
#include "furc/ast/expression.hpp"
#include "furc/ast/node.hpp"
#include "furc/ast/program.hpp"
#include "furc/ast/statement.hpp"
@@ -8,38 +8,12 @@
namespace furc::ast {
bool literal_node::equal(const node& rhs) const {
return literal_type() == reinterpret_cast<const literal_node&>(rhs).literal_type();
}
void string_literal_node::accept(visitor& visitor) const {
visitor.visit(*this);
}
std::ostream& string_literal_node::print(std::ostream& os) const {
if (m_value.has_error()) return os << m_value.error();
return os << '"' << *m_value << '"';
}
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;
}
void integer_literal_node::accept(visitor& visitor) const {
visitor.visit(*this);
}
std::ostream& integer_literal_node::print(std::ostream& os) const {
if (m_value.has_error()) return os << m_value.error();
return os << *m_value;
}
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;
std::ostream& operator<<(std::ostream& os, const error& error) {
return os << error.location << ": ERROR: unknown";
}
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 {
@@ -47,12 +21,12 @@ void var_read_expression_node::accept(visitor& visitor) const {
}
std::ostream& var_read_expression_node::print(std::ostream& os) const {
if (m_name.present()) return os << *m_name;
return os << m_name.error();
if (m_name.has_error()) return os << m_name.error();
return os << *m_name;
}
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;
}
@@ -73,6 +47,7 @@ void unaryop_expression_node::accept(visitor& visitor) const {
}
std::ostream& unaryop_expression_node::print(std::ostream& os) const {
if (!m_node.has_value()) return os;
switch (m_type) {
case unaryop_expression_node_t::Positive:
case unaryop_expression_node_t::Negative:
@@ -85,7 +60,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;
}
@@ -117,7 +92,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;
}
@@ -130,12 +105,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 {
@@ -147,7 +122,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 {
@@ -156,22 +131,21 @@ void function_definition_node::accept(visitor& visitor) const {
std::ostream& function_definition_node::print(std::ostream& os) const {
function_declaration_node::print(os);
os << ':';
if (m_body.present()) {
os << ":\n";
if (m_body.has_value()) {
for (const auto& entry : m_body->statements)
os << '\n' << entry;
return os << '\n' << m_body->end << ": " << p_name->string << " end";
os << entry << '\n';
return os << m_body->end << ": " << p_name->string << " end";
}
return os << m_body.error(); // error
return os << m_body.error();
}
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 {
@@ -180,12 +154,12 @@ void return_statement_node::accept(visitor& visitor) const {
std::ostream& return_statement_node::print(std::ostream& os) const {
os << "return statement";
if (m_value.present()) return os << ' ' << *m_value;
if (m_value.has_value()) return os << ' ' << *m_value.value();
return os;
}
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 {
@@ -195,12 +169,12 @@ void if_statement_node::accept(visitor& visitor) const {
std::ostream& if_statement_node::print(std::ostream& os) const {
os << "if " << *m_cond << ", then:\n";
os << m_then;
if (m_else.present()) os << m_else;
if (m_else.has_value()) os << *m_else.value();
return os;
}
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;
}
@@ -213,15 +187,15 @@ 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 {
for (const auto& decl : m_declarations) {
if (decl.has_error()) {
visitor.visit_error(decl);
visitor.visit_error(decl.error());
} else {
decl->accept(visitor);
decl.value()->accept(visitor);
}
}
}
@@ -235,7 +209,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/ir_generator.cpp
+20 -17
View File
@@ -22,7 +22,7 @@ void ir_generator::visit(const ast::function_definition_node& funcDef) {
return;
}
for (const auto& stmt : funcDef.body()->statements) {
stmt->accept(*this);
stmt.value()->accept(*this);
}
m_currentBlock->emplace<ir::return_instruction>();
@@ -30,12 +30,15 @@ void ir_generator::visit(const ast::function_definition_node& funcDef) {
}
void ir_generator::visit(const ast::return_statement_node& returnStmt) {
if (returnStmt.value().has_error()) {
std::cerr << returnStmt.value() << '\n';
if (!returnStmt.value().has_value()) return;
auto value = returnStmt.value().value();
if (value.has_error()) {
std::cerr << value.error() << '\n';
return;
}
if (returnStmt.value().present()) {
returnStmt.value()->accept(*this);
if (value.has_value()) {
value.value()->accept(*this);
push<ir::return_instruction>(ir::operand::new_reg(m_registerCounter - 1));
} else {
push<ir::return_instruction>();
@@ -43,19 +46,19 @@ void ir_generator::visit(const ast::return_statement_node& returnStmt) {
}
void ir_generator::visit(const ast::if_statement_node& node) {
node.cond()->accept(*this);
node.cond().value()->accept(*this);
ir_register cond = m_registerCounter - 1;
push<ir::branch_cond_instruction>(ir::operand::new_reg(cond),
m_currentFunction->blocks().size(),
m_currentFunction->blocks().size() + 1);
push_block(); // then block
node.then()->accept(*this);
if (node.elze().present()) {
node.then().value()->accept(*this);
if (node.elze().has_value()) {
m_currentBlock->emplace<ir::branch_instruction>(m_currentFunction->blocks().size() + 1);
push_block(); // else block
node.elze()->accept(*this);
node.elze().value().value()->accept(*this);
}
m_currentBlock->emplace<ir::branch_instruction>(m_currentFunction->blocks().size());
@@ -64,17 +67,17 @@ void ir_generator::visit(const ast::if_statement_node& node) {
void ir_generator::visit(const ast::compound_statement_node& node) {
for (const auto& stmt : node.body()->statements) {
stmt->accept(*this);
stmt.value()->accept(*this);
}
}
void ir_generator::visit(const ast::string_literal_node& node) {
push<furlang::ir::assign_instruction>(ir::operand::new_string(std::string(*node.value())),
push<furlang::ir::assign_instruction>(ir::operand::new_string(node.value()),
ir::operand::new_reg(m_registerCounter++));
}
void ir_generator::visit(const ast::integer_literal_node& node) {
push<furlang::ir::assign_instruction>(ir::operand::new_integer(*node.value()),
push<furlang::ir::assign_instruction>(ir::operand::new_integer(node.value()),
ir::operand::new_reg(m_registerCounter++));
}
@@ -110,9 +113,9 @@ static inline furlang::ir::binary_op_instruction_t binary_op_instruction_t(ast::
}
void ir_generator::visit(const ast::binop_expression_node& node) {
node.lhs()->accept(*this);
node.lhs().value()->accept(*this);
ir_register lhs = m_registerCounter - 1;
node.rhs()->accept(*this);
node.rhs().value()->accept(*this);
ir_register rhs = m_registerCounter - 1;
ir_register dst = m_registerCounter++;
push<furlang::ir::binary_op_instruction>(binary_op_instruction_t(node.type()),
@@ -122,10 +125,10 @@ void ir_generator::visit(const ast::binop_expression_node& node) {
}
void ir_generator::visit(const ast::var_assign_expression_node& node) {
node.rhs()->accept(*this);
node.rhs().value()->accept(*this);
ir_register rhs = m_registerCounter - 1;
assert(node.lhs()->expression_type() == ast::expression_node_t::VarRead);
ast::var_read_expression_node_h lhs = node.lhs();
assert(node.lhs().value()->expression_type() == ast::expression_node_t::VarRead);
auto lhs = std::dynamic_pointer_cast<ast::var_read_expression_node>(node.lhs().value());
ir_register reg = 0;
if (auto it = m_variables.find(*lhs->get_name()); it != m_variables.end()) {
furc/src/front/lexer.cpp
+12 -6
View File
@@ -13,7 +13,7 @@ using namespace std::string_literals;
lexer::lexer(std::string_view filename, std::string_view content)
: m_filename(filename), m_content(content) {}
token_handle<> lexer::next_token() {
token_r lexer::next_token() {
skip_spaces();
while (m_cursor + 2 <= m_content.size() && m_content[m_cursor] == '/') {
if (m_content[m_cursor + 1] == '/') {
@@ -35,7 +35,8 @@ token_handle<> lexer::next_token() {
}
if (m_cursor + 2 >= m_content.size()) {
next();
return { current_location(), "unexpected end of file before enclosing `*/`" };
return token_r(
token_error{ current_location(), token_error_t::UnexpectedEof, "before enclosing `*/`" });
}
m_cursor += 2;
} else {
@@ -51,12 +52,14 @@ token_handle<> lexer::next_token() {
std::size_t begin = ++m_cursor;
while (m_cursor < m_content.size() && m_content[m_cursor] != '"')
++m_cursor;
if (m_cursor >= m_content.size()) return { current_location(), "unexpected end of file before enclosing '\"'" };
if (m_cursor >= m_content.size()) {
return token_r(token_error{ current_location(), token_error_t::UnexpectedEof, "before enclosing '\"'" });
}
++m_cursor;
return { location, token_t::String, m_content.substr(begin, m_cursor - begin - 1) };
}
case std::char_traits<char>::eof(): return { location, token_t::None };
case std::char_traits<char>::eof(): return token_r(token_error{ current_location(), token_error_t::EndOfFile });
default: {
if (std::isdigit(get()) != 0) {
integer_token integer = 0;
@@ -70,7 +73,9 @@ token_handle<> lexer::next_token() {
if (integer > upperBound || integer == upperBound && (integer - upperBound + digit) > (max % 10)) {
while (std::isdigit(get()) != 0)
++m_cursor;
return { location, "integer "s.append(m_content.substr(start, m_cursor - start)) + " is too big" };
return token_r(token_error{ location,
token_error_t::IntegerOverflow,
std::string(m_content.substr(start, m_cursor - start)) });
}
integer *= 10;
integer += digit;
@@ -150,7 +155,8 @@ token_handle<> lexer::next_token() {
return { location, type };
}
return { location, "unexpected character '"s.append(m_content.substr(m_cursor, length)) + "'" };
return token_r(
token_error{ location, token_error_t::UnexpectedCharacter, std::string(m_content.substr(m_cursor, 1)) });
}
}
}
furc/src/front/parser.cpp
+88 -101
View File
@@ -30,47 +30,47 @@ parser::parser(std::string_view filename)
m_lexer = { filename, m_content };
}
ast::program_node_h parser::parse() & {
auto program = m_arena.allocate_shared<ast::program_node>();
ast::program_node_r parser::parse() & {
auto program = m_arena.allocate_shared<ast::program_node>(location{ m_filename });
while (peek_token().present() && peek_token()->type != token_t::None && !m_lexer.empty()) {
while (peek_token().has_value()) {
program->push(std::move(parse_declaration()));
}
return { location{ m_filename, 0, 0 }, program };
return program;
}
ast::declaration_node_h parser::parse_declaration() {
ast::declaration_node_r parser::parse_declaration() {
const auto& first = peek_token();
switch (first->type) {
case token_t::Keyword: {
auto first = next_token();
switch ((*first)->keyword) {
case keyword_token::Func: {
token_handle<> name = eat_token(token_t::Identifier);
if (name.has_error()) return { name.location(), name.error() };
auto name = eat_token(token_t::Identifier);
if (name.has_error()) return ast::declaration_node_r(ast::error{ name.error().location });
auto tok = eat_token(token_t::LParen);
if (tok.has_error()) return tok;
if (tok.has_error()) return ast::declaration_node_r(ast::error{ tok.error().location });
tok = eat_token(token_t::RParen);
if (tok.has_error()) return tok;
if (tok.has_error()) return ast::declaration_node_r(ast::error{ tok.error().location });
const auto& peek = peek_token();
if (peek.has_error()) return peek;
if (peek.has_error()) return ast::declaration_node_r(ast::error{ peek.error().location });
switch (peek->type) {
case token_t::LBrace: {
ast::body_h body = parse_body();
if (body.has_error()) return body;
return ast::function_definition_node_h{ first.location(), m_arena, *name, std::move(body) };
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>(first->location, *name, std::move(body));
}
case token_t::Semicolon: {
m_peekBuffer.clear();
return ast::function_declaration_node_h{ first.location(), m_arena, *name };
return m_arena.allocate_shared<ast::function_declaration_node>(first->location, *name);
}
default: return { tok.location(), "unexpected token "s + tok->type };
default: return ast::declaration_node_r(ast::error{ tok->location });
}
}
default: return { first.location(), "unexpected keyword "s + (*first)->keyword };
default: return ast::declaration_node_r(ast::error{ first->location });
}
}
case token_t::None:
@@ -85,15 +85,15 @@ ast::declaration_node_h parser::parse_declaration() {
case token_t::Semicolon:
case token_t::Colon:
default: {
return { first.location(), "unexpected token "s + first->type };
return ast::declaration_node_r(ast::error{ first->location });
}
}
}
ast::statement_node_h parser::parse_statement() {
ast::statement_node_r parser::parse_statement() {
const auto& tok = peek_token();
if (tok.has_error()) return tok;
auto location = tok.location();
if (tok.has_error()) return ast::statement_node_r(ast::error{ tok.error().location });
auto location = tok->location;
switch (tok->type) {
case token_t::Keyword: {
switch (tok->value.keyword) {
@@ -101,107 +101,92 @@ ast::statement_node_h parser::parse_statement() {
auto tok = next_token();
if (peek_token()->type == token_t::Semicolon) {
next_token();
return ast::return_statement_node_h{ tok.location(), m_arena };
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 err;
return ast::return_statement_node_h{ tok.location(), m_arena, std::move(value) };
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
return m_arena.allocate_shared<ast::return_statement_node>(location, std::move(value));
}
case keyword_token::If: {
auto tok = next_token();
auto err = eat_token(token_t::LParen);
if (err.has_error()) return err;
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
auto cond = parse_expression();
err = eat_token(token_t::RParen);
if (err.has_error()) return err;
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
auto then = parse_statement();
if (then.has_error()) return then;
if (then.has_error()) return ast::statement_node_r(ast::error{ then.error().location });
if (peek_token().present() && peek_token()->type == token_t::Keyword &&
if (peek_token().has_value() && peek_token()->type == token_t::Keyword &&
peek_token()->value.keyword == keyword_token::Else) {
next_token();
return ast::if_statement_node_h{ location,
m_arena,
return m_arena.allocate_shared<ast::if_statement_node>(location,
std::move(cond),
std::move(then),
std::move(parse_statement()) };
std::move(parse_statement()));
}
return ast::if_statement_node_h{ location, m_arena, 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 ast::compound_statement_node_h{ location, m_arena, parse_body() };
case token_t::LBrace: return m_arena.allocate_shared<ast::compound_statement_node>(location, parse_body());
default: break;
}
auto declaration = parse_declaration();
if (declaration.present()) return std::move(declaration);
if (declaration.has_value()) return std::move(*declaration);
auto expression = parse_expression();
if (expression.present()) {
if (expression.has_value()) {
auto semi = eat_token(token_t::Semicolon);
if (semi.has_error()) return semi;
return std::move(expression);
if (semi.has_error()) return ast::statement_node_r(ast::error{ semi.error().location });
return std::move(*expression);
}
auto token = next_token();
return { token.location(), "unexpected token "s + token->type + ", expected statement, declaration or expression" };
return ast::statement_node_r(ast::error{ token->location });
}
ast::expression_node_h parser::parse_expression(std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression(std::uint32_t precedence) {
return parse_expression_rhs(parse_expression_unary(precedence), precedence);
}
ast::literal_node_h parser::parse_literal() {
const auto& tok = peek_token();
switch (tok->type) {
case token_t::String: {
auto tok = next_token();
return ast::string_literal_node_h{ tok.location(),
m_arena,
handle<std::string_view>{ tok.location(), (*tok)->string } };
}
case token_t::Integer: {
auto tok = next_token();
return ast::integer_literal_node_h{ tok.location(),
m_arena,
handle<integer_token>{ tok.location(), (*tok)->integer } };
}
default: break;
}
return { tok.location(), "unexpected token "s + tok->type + ", expected literal" };
}
ast::expression_node_h parser::parse_expression_primary() {
ast::expression_node_r parser::parse_expression_primary() {
const auto& tok = peek_token();
switch (tok->type) {
case token_t::Identifier: {
auto tok = next_token();
return ast::var_read_expression_node_h{ tok.location(),
m_arena,
handle<std::string_view>{ tok.location(), (*tok)->string } };
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->location, (*tok)->string);
}
case token_t::LParen: {
auto tok = next_token();
auto node = parse_expression();
auto err = eat_token(token_t::RParen);
if (err.has_error()) return err;
if (err.has_error()) return ast::expression_node_r(ast::error{ err.error().location });
return node;
}
case token_t::String: {
auto tok = next_token();
if (tok.has_error()) return ast::expression_node_r(ast::error{ tok.error().location });
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::expression_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::integer_literal_node>(tok->location, (*tok)->integer);
}
default: {
auto literal = parse_literal();
if (literal.present()) return std::move(literal);
return { tok.location(), "unexpected token"s + tok->type + ", expected expression or literal" };
return ast::expression_node_r(ast::error{ tok->location });
}
}
}
@@ -211,7 +196,7 @@ struct unaryop_info {
std::uint32_t precedence;
};
ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression_unary(std::uint32_t precedence) {
static std::unordered_map<token_t, unaryop_info> s_prefixes = {
{ token_t::Plus, unaryop_info{ ast::unaryop_expression_node_t::Positive, 3 } },
{ token_t::Minus, unaryop_info{ ast::unaryop_expression_node_t::Negative, 3 } },
@@ -219,7 +204,7 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
{ token_t::DMinus, unaryop_info{ ast::unaryop_expression_node_t::PrefixDecrement, 2 } },
};
ast::unaryop_expression_node_h result;
std::shared_ptr<ast::unaryop_expression_node> result;
while (true) {
auto it = s_prefixes.find(peek_token()->type);
if (it == s_prefixes.end()) break;
@@ -227,7 +212,7 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
if (current.precedence >= precedence) break;
auto token = next_token();
ast::expression_node_h expression;
ast::expression_node_r expression;
auto nextIt = s_prefixes.find(peek_token()->type);
if (nextIt != s_prefixes.end()) {
@@ -235,11 +220,12 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
expression = parse_expression_unary(current.precedence + 1);
}
result = { token.location(), m_arena, current.type, std::move(expression) };
result =
m_arena.allocate_shared<ast::unaryop_expression_node>(token->location, current.type, std::move(expression));
}
if (!result.present()) return parse_expression_primary();
if (!result->get_node().present()) result->set_node(parse_expression_primary());
if (result == nullptr) return parse_expression_primary();
if (result->get_node().has_value()) result->set_node(parse_expression_primary());
return result;
}
@@ -294,7 +280,7 @@ struct rhsop_info {
}
};
ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& init, std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression_rhs(ast::expression_node_r&& init, std::uint32_t precedence) {
static std::unordered_map<token_t, rhsop_info> s_rhsops = {
{ token_t::Plus, rhsop_info::create(ast::binop_expression_node_t::Add, 5, associativity::Left) },
{ token_t::Minus, rhsop_info::create(ast::binop_expression_node_t::Sub, 5, associativity::Left) },
@@ -318,8 +304,8 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
{ token_t::GreaterEq, rhsop_info::create(ast::binop_expression_node_t::GreaterEqual, 9, associativity::Left) },
};
ast::expression_node_h lhs = std::move(init);
while (peek_token().present()) {
ast::expression_node_r lhs = std::move(init);
while (peek_token().has_value()) {
auto it = s_rhsops.find(peek_token()->type);
if (it == s_rhsops.end()) return lhs;
@@ -327,7 +313,7 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
if (current.precedence >= precedence) return lhs;
auto opToken = next_token();
ast::expression_node_h rhs;
ast::expression_node_r rhs;
if (current.type != rhsop_info_t::Unaryop) {
rhs = parse_expression_unary(current.precedence + 1); // unary prefix is always right-associative
}
@@ -346,68 +332,69 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
switch (current.type) {
case rhsop_info_t::Unaryop:
lhs = ast::unaryop_expression_node_h{ opToken.location(), m_arena, 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 = ast::binop_expression_node_h{ opToken.location(),
m_arena,
lhs = m_arena.allocate_shared<ast::binop_expression_node>(opToken->location,
current.binary,
std::move(lhs),
std::move(rhs) };
std::move(rhs));
break;
case rhsop_info_t::Assignment:
lhs = ast::var_assign_expression_node_h{ opToken.location(),
m_arena,
lhs = m_arena.allocate_shared<ast::var_assign_expression_node>(opToken->location,
current.assignment,
std::move(lhs),
std::move(rhs) };
std::move(rhs));
break;
}
}
return lhs;
}
ast::body_h parser::parse_body() {
ast::body_r parser::parse_body() {
ast::body body;
token_handle<> begin = eat_token(token_t::LBrace);
if (begin.has_error()) return begin;
body.begin = begin.location();
auto begin = eat_token(token_t::LBrace);
if (begin.has_error()) return ast::body_r(ast::error{ begin.error().location });
body.begin = begin->location;
while (!peek_token().has_error() && peek_token()->type != token_t::None && peek_token()->type != token_t::RBrace) {
body.statements.push_back(parse_statement());
}
token_handle<> end = eat_token(token_t::RBrace);
if (end.has_error()) return end;
body.end = end.location();
auto end = eat_token(token_t::RBrace);
if (end.has_error()) return ast::body_r(ast::error{ end.error().location });
body.end = end->location;
return { begin.location(), body };
return body;
}
token_handle<> parser::next_token() {
token_r parser::next_token() {
if (!m_peekBuffer.empty()) {
token_handle<> token = std::move(m_peekBuffer.back());
auto token = std::move(m_peekBuffer.back());
m_peekBuffer.pop_back();
return token;
}
return m_lexer.next_token();
}
const token_handle<>& parser::peek_token() {
const token_r& parser::peek_token() {
if (m_peekBuffer.empty()) {
token_handle<> token = m_lexer.next_token();
auto token = m_lexer.next_token();
return m_peekBuffer.emplace_back(std::move(token));
}
return m_peekBuffer.front();
}
token_handle<> parser::eat_token(token_t type) {
token_handle<> token = next_token();
if (!token.present()) return token;
token_r parser::eat_token(token_t type) {
auto token = next_token();
if (token.has_error()) return token;
if (token->type != type) {
if (token->type == token_t::None) return { token.location(), "unexpected end of file, expected " + type };
return { token.location(), "unexpected token "s + token->type + ", expected " + type };
if (token->type == token_t::None)
return token_r(token_error{ token->location, token_error_t::UnexpectedToken, ", expected " + type });
return token_r(
token_error{ token->location, token_error_t::UnexpectedToken, ""s + token->type + ", expected " + type });
}
return token;
}
furc/src/main.cpp
+29 -22
View File
@@ -7,7 +7,8 @@
#include <iostream>
int main(void) {
std::string programStr = R"(
try {
std::string programStr = R"(
func main() {
x = 5;
x -= 3;
@@ -21,30 +22,36 @@ int main(void) {
z = x + y;
}
)";
furc::front::parser parser("<TEMP>", programStr);
furc::front::ir_generator generator;
furc::front::parser parser("<TEMP>", programStr);
furc::front::ir_generator generator;
auto program = parser.parse();
if (program.has_error()) {
std::cerr << program << '\n';
}
program->accept(generator);
auto module = std::move(generator.move_module());
std::cout << "Generated IR:\n";
for (const auto& function : module.functions()) {
std::cout << function->name() << ":\n";
furlang::ir::block_index blockIndex = 0;
for (const auto& block : function->blocks()) {
std::cout << " # block " << blockIndex++ << '\n';
for (const auto& instruction : block->instructions()) {
std::cout << " " << *instruction << '\n';
}
std::cout << " " << *block->exit() << '\n';
auto programResult = parser.parse();
if (programResult.has_error()) {
std::cerr << programResult.error() << '\n';
return 1;
}
}
const auto& program = *programResult;
program->accept(generator);
return 0;
auto module = std::move(generator.move_module());
std::cout << "Generated IR:\n";
for (const auto& function : module.functions()) {
std::cout << function->name() << ":\n";
furlang::ir::block_index blockIndex = 0;
for (const auto& block : function->blocks()) {
std::cout << " # block " << blockIndex++ << '\n';
for (const auto& instruction : block->instructions()) {
std::cout << " " << *instruction << '\n';
}
std::cout << " " << *block->exit() << '\n';
}
}
return 0;
} catch (...) {
std::cerr << "Caught an exception in main!\n";
return 1;
}
}
#endif // LIBFURC
furc/test/lexer.cpp
+32 -30
View File
@@ -2,8 +2,6 @@
#include "furc/front/lexer.hpp"
#include "furlang/result.hpp"
#include "gtest/gtest.h"
#include <string>
@@ -13,7 +11,6 @@ using namespace furc::front;
using namespace std::string_view_literals;
using namespace std::string_literals;
using token_r = furlang::result<token, std::string>;
using lexer_case = std::pair<std::string, std::vector<token_r>>;
class LexerTestingFixture : public testing::TestWithParam<lexer_case> {};
@@ -26,16 +23,16 @@ TEST_P(LexerTestingFixture, LexerTest) {
while (it != expected.end()) {
const auto& expected = *it++;
auto token = std::move(lexer.next_token());
if (expected.has_error()) {
EXPECT_TRUE(token.has_error());
EXPECT_EQ(token.error(), expected.error());
} else {
EXPECT_EQ(token, expected.value());
}
EXPECT_EQ(lexer.next_token(), expected);
}
// EOF
EXPECT_EQ(lexer.next_token(), token{});
auto eof = std::move(lexer.next_token());
ASSERT_TRUE(eof.has_error());
ASSERT_EQ(eof.error().type, token_error_t::EndOfFile);
}
furc::location loc(size_t col, size_t line) {
return furc::location{ "<TEMP>", line, col };
}
INSTANTIATE_TEST_SUITE_P(EmptyTests,
@@ -45,31 +42,36 @@ INSTANTIATE_TEST_SUITE_P(EmptyTests,
INSTANTIATE_TEST_SUITE_P(Comments,
LexerTestingFixture,
testing::Values(lexer_case("(/** skibidi **/func{//)\n}",
{ { token_t::LParen }, { keyword_token::Func }, { token_t::LBrace }, { token_t::RBrace } })));
{ { loc(0, 0), token_t::LParen },
{ loc(16, 0), keyword_token::Func },
{ loc(20, 0), token_t::LBrace },
{ loc(0, 1), token_t::RBrace } })));
INSTANTIATE_TEST_SUITE_P(Integers,
LexerTestingFixture,
testing::Values(lexer_case("67 6\n7", { { 67 }, { 6 }, { 7 } }),
lexer_case("18446744073709551615 18446744073709551616",
{ { 18446744073709551615ULL }, token_r(std::string("integer 18446744073709551616 is too big")) })));
testing::Values(lexer_case("67 6\n7", { { loc(0, 0), 67 }, { loc(3, 0), 6 }, { loc(0, 1), 7 } }),
lexer_case("18446744073709551615\n18446744073709551616",
{ { loc(0, 0), 18446744073709551615ULL },
token_r(
token_error{ loc(0, 1), token_error_t::IntegerOverflow, std::string("18446744073709551616") }) })));
INSTANTIATE_TEST_SUITE_P(Tokens,
LexerTestingFixture,
testing::Values(lexer_case("()\n\t\t{\n}[\"shto-to\"]; :,.main return func",
{ { token_t::LParen },
{ token_t::RParen },
{ token_t::LBrace },
{ token_t::RBrace },
{ token_t::LBracket },
{ token_t::String, "shto-to"sv },
{ token_t::RBracket },
{ token_t::Semicolon },
{ token_t::Colon },
{ token_t::Comma },
{ token_t::Dot },
{ token_t::Identifier, "main"sv },
{ keyword_token::Return },
{ keyword_token::Func } })));
{ { loc(0, 0), token_t::LParen },
{ loc(1, 0), token_t::RParen },
{ loc(2, 1), token_t::LBrace },
{ loc(0, 2), token_t::RBrace },
{ loc(1, 2), token_t::LBracket },
{ loc(2, 2), token_t::String, "shto-to"sv },
{ loc(10, 2), token_t::RBracket },
{ loc(11, 2), token_t::Semicolon },
{ loc(15, 2), token_t::Colon },
{ loc(16, 2), token_t::Comma },
{ loc(17, 2), token_t::Dot },
{ loc(18, 2), token_t::Identifier, "main"sv },
{ loc(23, 2), keyword_token::Return },
{ loc(30, 2), keyword_token::Func } })));
} // namespace
furc/test/parser.cpp
+223 -229
View File
@@ -6,7 +6,7 @@
#include "furc/ast/program.hpp" // IWYU pragma: keep
#include "furc/ast/statement.hpp" // IWYU pragma: keep
#include "gtest/gtest.h"
#include "gtest/gtest.h" // IWYU pragma: keep
namespace {
@@ -14,267 +14,261 @@ using namespace furc::front;
using namespace furc::ast;
using namespace std::string_view_literals;
TEST(Parser, EmptyFunctions) {
parser parser("<TEMP>", "func main() {}\nfunc foo();");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 2);
{
auto first = program->declarations()[0];
EXPECT_TRUE(first.present());
EXPECT_EQ(first->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = first;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 0);
}
{
auto second = program->declarations()[1];
EXPECT_TRUE(second.present());
EXPECT_EQ(second->declaration_type(), declaration_node_t::Func);
function_declaration_node_h funcDecl = second;
EXPECT_EQ(funcDecl->name()->string, "foo");
}
}
// TEST(Parser, EmptyFunctions) {
// parser parser("<TEMP>", "func main() {}\nfunc foo();");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 2);
// {
// auto first = program->declarations()[0];
// EXPECT_TRUE(first.present());
// EXPECT_EQ(first->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = first;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 0);
// }
// {
// auto second = program->declarations()[1];
// EXPECT_TRUE(second.present());
// EXPECT_EQ(second->declaration_type(), declaration_node_t::Func);
// function_declaration_node_h funcDecl = second;
// EXPECT_EQ(funcDecl->name()->string, "foo");
// }
// }
TEST(Parser, Literals) {
parser parser("<TEMP>", R"(
func test1() { return 67; }
func test2() { return "uwu"; }
)");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 2);
{
auto test1 = program->declarations()[0];
EXPECT_TRUE(test1.present());
EXPECT_EQ(test1->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = test1;
EXPECT_EQ(funcDef->name()->string, "test1");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
EXPECT_EQ(ret->value(), integer_literal_node({ furc::location{ "<TEMP>", 1, 26 }, 67 }));
}
{
auto test2 = program->declarations()[1];
EXPECT_TRUE(test2.present());
EXPECT_EQ(test2->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDecl = test2;
EXPECT_EQ(funcDecl->name()->string, "test2");
}
}
// #define EXPECT_INTLIT(expr, integer) \
// do { \
// EXPECT_EQ((expr)->expression_type(), expression_node_t::Literal); \
// literal_node_h literal = (expr); \
// EXPECT_EQ(literal->literal_type(), literal_node_t::Integer); \
// integer_literal_node_h intLit = literal; \
// EXPECT_EQ(intLit->value(), integer_token((integer))); \
// } while (0)
#define EXPECT_INTLIT(expr, integer) \
do { \
EXPECT_EQ((expr)->expression_type(), expression_node_t::Literal); \
literal_node_h literal = (expr); \
EXPECT_EQ(literal->literal_type(), literal_node_t::Integer); \
integer_literal_node_h intLit = literal; \
EXPECT_EQ(*intLit, (integer)); \
} while (0)
// TEST(Parser, Literals) {
// parser parser("<TEMP>", R"(
// func test1() { return 67; }
// func test2() { return "uwu"; }
// )");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 2);
// {
// auto test1 = program->declarations()[0];
// EXPECT_TRUE(test1.present());
// EXPECT_EQ(test1->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = test1;
// EXPECT_EQ(funcDef->name()->string, "test1");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
// EXPECT_INTLIT(ret->value(), 67);
// }
// {
// auto test2 = program->declarations()[1];
// EXPECT_TRUE(test2.present());
// EXPECT_EQ(test2->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDecl = test2;
// EXPECT_EQ(funcDecl->name()->string, "test2");
// }
// }
#define EXPECT_VARREAD(expr, varname) \
do { \
EXPECT_EQ((expr)->expression_type(), expression_node_t::VarRead); \
var_read_expression_node_h varRead = (expr); \
EXPECT_EQ(varRead->get_name(), (varname)); \
} while (0)
// #define EXPECT_VARREAD(expr, varname) \
// do { \
// EXPECT_EQ((expr)->expression_type(), expression_node_t::VarRead); \
// var_read_expression_node_h varRead = (expr); \
// EXPECT_EQ(varRead->get_name(), (varname)); \
// } while (0)
// TODO: Use arena (I am too exhausted rn to do it)
TEST(Parser, OperatorPrecedence_AddMul) {
parser parser("<TEMP>", "func main() { return 1 + 2 * 3; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
// // TODO: Use arena (I am too exhausted rn to do it)
// TEST(Parser, OperatorPrecedence_AddMul) {
// parser parser("<TEMP>", "func main() { return 1 + 2 * 3; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
binop_expression_node_h add = retVal;
EXPECT_EQ(add->type(), binop_expression_node_t::Add);
EXPECT_INTLIT(add->lhs(), 1);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
// binop_expression_node_h add = retVal;
// EXPECT_EQ(add->type(), binop_expression_node_t::Add);
// EXPECT_INTLIT(add->lhs(), 1);
EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h mul = add->rhs();
EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
EXPECT_INTLIT(mul->lhs(), 2);
EXPECT_INTLIT(mul->rhs(), 3);
}
// EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h mul = add->rhs();
// EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
// EXPECT_INTLIT(mul->lhs(), 2);
// EXPECT_INTLIT(mul->rhs(), 3);
// }
TEST(Parser, OperatorPrecedence_Complex) {
parser parser("<TEMP>", "func main() { return 1 + 2 * 3 - 4 / 2; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, OperatorPrecedence_Complex) {
// parser parser("<TEMP>", "func main() { return 1 + 2 * 3 - 4 / 2; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
binop_expression_node_h sub = retVal;
EXPECT_EQ(sub->type(), binop_expression_node_t::Sub);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
// binop_expression_node_h sub = retVal;
// EXPECT_EQ(sub->type(), binop_expression_node_t::Sub);
EXPECT_EQ(sub->lhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h add = sub->lhs();
EXPECT_EQ(add->type(), binop_expression_node_t::Add);
EXPECT_INTLIT(add->lhs(), 1);
// EXPECT_EQ(sub->lhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h add = sub->lhs();
// EXPECT_EQ(add->type(), binop_expression_node_t::Add);
// EXPECT_INTLIT(add->lhs(), 1);
EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h mul = add->rhs();
EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
EXPECT_INTLIT(mul->lhs(), 2);
EXPECT_INTLIT(mul->rhs(), 3);
// EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h mul = add->rhs();
// EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
// EXPECT_INTLIT(mul->lhs(), 2);
// EXPECT_INTLIT(mul->rhs(), 3);
EXPECT_EQ(sub->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h div = sub->rhs();
EXPECT_EQ(div->type(), binop_expression_node_t::Div);
EXPECT_INTLIT(div->lhs(), 4);
EXPECT_INTLIT(div->rhs(), 2);
}
// EXPECT_EQ(sub->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h div = sub->rhs();
// EXPECT_EQ(div->type(), binop_expression_node_t::Div);
// EXPECT_INTLIT(div->lhs(), 4);
// EXPECT_INTLIT(div->rhs(), 2);
// }
TEST(Parser, UnaryOperator_Simple) {
parser parser("<TEMP>", "func main() { return -5; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, UnaryOperator_Simple) {
// parser parser("<TEMP>", "func main() { return -5; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h neg = retVal;
EXPECT_EQ(neg->type(), unaryop_expression_node_t::Negative);
EXPECT_INTLIT(neg->get_node(), 5);
}
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h neg = retVal;
// EXPECT_EQ(neg->type(), unaryop_expression_node_t::Negative);
// EXPECT_INTLIT(neg->get_node(), 5);
// }
TEST(Parser, UnaryOperator_PrePost) {
parser parser("<TEMP>", "func main() { return --5++; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, UnaryOperator_PrePost) {
// parser parser("<TEMP>", "func main() { return --5++; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h inc = retVal;
EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h inc = retVal;
// EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
EXPECT_EQ(inc->get_node()->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h dec = inc->get_node();
EXPECT_INTLIT(dec->get_node(), 5);
}
// EXPECT_EQ(inc->get_node()->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h dec = inc->get_node();
// EXPECT_INTLIT(dec->get_node(), 5);
// }
TEST(Parser, Paren) {
parser parser("<TEMP>", "func main() { return --(x++); }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, Paren) {
// parser parser("<TEMP>", "func main() { return --(x++); }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h dec = retVal;
EXPECT_EQ(dec->type(), unaryop_expression_node_t::PrefixDecrement);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h dec = retVal;
// EXPECT_EQ(dec->type(), unaryop_expression_node_t::PrefixDecrement);
EXPECT_EQ(dec->get_node()->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h inc = dec->get_node();
EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
EXPECT_VARREAD(inc->get_node(), "x");
}
// EXPECT_EQ(dec->get_node()->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h inc = dec->get_node();
// EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
// EXPECT_VARREAD(inc->get_node(), "x"sv);
// }
TEST(Parser, Assignment) {
parser parser("<TEMP>", "func main() { x = 10; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
// TEST(Parser, Assignment) {
// parser parser("<TEMP>", "func main() { x = 10; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
expression_node_h expr = funcDef->body()->statements[0];
// EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
// expression_node_h expr = funcDef->body()->statements[0];
EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
var_assign_expression_node_h assign = expr;
EXPECT_EQ(assign->compound(), binop_expression_node_t::None);
// EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
// var_assign_expression_node_h assign = expr;
// EXPECT_EQ(assign->compound(), binop_expression_node_t::None);
expression_node_h lhs = assign->lhs();
EXPECT_EQ(lhs->expression_type(), expression_node_t::VarRead);
var_read_expression_node_h varRead = lhs;
EXPECT_EQ(varRead->get_name(), "x");
// EXPECT_VARREAD(assign->lhs(), "x"sv);
expression_node_h rhs = assign->rhs();
EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
EXPECT_INTLIT(rhs, 10);
}
// expression_node_h rhs = assign->rhs();
// EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
// EXPECT_INTLIT(rhs, 10);
// }
TEST(Parser, CompoundAssignment) {
parser parser("<TEMP>", "func main() { x += 10; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDef = func;
EXPECT_EQ(funcDef->name()->string, "main");
EXPECT_EQ(funcDef->body()->statements.size(), 1);
// TEST(Parser, CompoundAssignment) {
// parser parser("<TEMP>", "func main() { x += 10; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDef = func;
// EXPECT_EQ(funcDef->name()->string, "main");
// EXPECT_EQ(funcDef->body()->statements.size(), 1);
EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
expression_node_h expr = funcDef->body()->statements[0];
// EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
// expression_node_h expr = funcDef->body()->statements[0];
EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
var_assign_expression_node_h assign = expr;
EXPECT_EQ(assign->compound(), binop_expression_node_t::Add);
// EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
// var_assign_expression_node_h assign = expr;
// EXPECT_EQ(assign->compound(), binop_expression_node_t::Add);
expression_node_h lhs = assign->lhs();
EXPECT_EQ(lhs->expression_type(), expression_node_t::VarRead);
var_read_expression_node_h varRead = lhs;
EXPECT_EQ(varRead->get_name(), "x");
// EXPECT_VARREAD(assign->lhs(), "x"sv);
expression_node_h rhs = assign->rhs();
EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
EXPECT_INTLIT(rhs, 10);
}
// expression_node_h rhs = assign->rhs();
// EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
// EXPECT_INTLIT(rhs, 10);
// }
} // namespace
furlang/include/furlang/result.hpp
+16
View File
@@ -199,6 +199,22 @@ public:
*/
bool operator!=(const result& rhs) const { return !this->operator==(rhs); }
/**
* @brief Compares a result with a value for equality.
*
* @param rhs Value to compare against.
* @return true if the values are equal.
*/
bool operator==(const value_type& rhs) const { return !m_error && m_value.result == rhs; }
/**
* @brief Compares a result with a value for inequality.
*
* @param rhs Value to compare against.
* @return true if the values are not equal.
*/
bool operator!=(const value_type& rhs) const { return !this->operator==(rhs); }
/**
* @brief Returns a reference to value.
*