chore: refactory ast

Author: nos1dot618

include/lbd/frontend/ast/Ast.hpp

@@ -12,7 +12,6 @@ namespace lbd::frontend::ast
 {
     struct IdentifierAstNode
     {
-        // TODO: This can be a std::string_view.
         std::string value;
         source::Location location;
 

include/lbd/frontend/ast/AstNode.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <lbd/frontend/ast/AstNodeKind.hpp>
+#include <lbd/source/Range.hpp>
+
+namespace lbd::frontend::ast
+{
+    class AstNode
+    {
+    public:
+        AstNode(AstNodeKind kind, source::Range range);
+        virtual ~AstNode() = default;
+
+        virtual void print(std::ostream& outputStream, size_t indent) const noexcept = 0;
+        friend std::ostream& operator<<(std::ostream& outputStream, const AstNode& node);
+
+    private:
+        const AstNodeKind kind;
+        const source::Range range;
+
+    protected:
+        static void printIndent(std::ostream& outputStream, size_t indent) noexcept;
+    };
+}

include/lbd/frontend/ast/AstNodeKind.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace lbd::frontend::ast
+{
+    enum class AstNodeKind
+    {
+        IDENTIFIER_EXPRESSION,
+        STRING_EXPRESSION,
+        NUMBER_EXPRESSION,
+        LAMBDA_EXPRESSION,
+        FUNCTION_APPLICATION_EXPRESSION,
+        SYMBOL_DEFINITION,
+        EXPRESSION_STATEMENT,
+        SYMBOL_DEFINITION_STATEMENT,
+    };
+}

include/lbd/frontend/ast/expression/Expression.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <lbd/frontend/ast/AstNode.hpp>
+
+namespace lbd::frontend::ast::expression
+{
+    class Expression : public AstNode
+    {
+        using AstNode::AstNode;
+    };
+}

include/lbd/frontend/ast/expression/IdentifierExpression.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <lbd/frontend/ast/expression/Expression.hpp>
+
+namespace lbd::frontend::ast::expression
+{
+    class IdentifierExpression final : Expression
+    {
+    public:
+        IdentifierExpression(const source::Range& range, std::string name) noexcept;
+
+        void print(std::ostream& outputStream, size_t indent) const noexcept override;
+
+    private:
+        std::string name;
+    };
+}

include/lbd/frontend/ast/expression/LambdaExpression.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <lbd/frontend/ast/expression/Expression.hpp>
+#include <lbd/frontend/ast/expression/IdentifierExpression.hpp>
+
+namespace lbd::frontend::ast::expression
+{
+    class NumberExpression final : Expression
+    {
+    public:
+        NumberExpression(const source::Range& range, std::string value) noexcept;
+
+        void print(std::ostream& outputStream, size_t indent) const noexcept override;
+
+    private:
+        IdentifierExpression argumentIdentifierExpression;
+        interpreter::type::Type argumentType;
+        std::unique_ptr<Expression> expression;
+        source::Location location;
+    };
+}

include/lbd/frontend/ast/expression/NumberExpression.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <lbd/frontend/ast/expression/Expression.hpp>
+
+namespace lbd::frontend::ast::expression
+{
+    class NumberExpression final : Expression
+    {
+    public:
+        NumberExpression(const source::Range& range, double value) noexcept;
+
+        void print(std::ostream& outputStream, size_t indent) const noexcept override;
+
+    private:
+        double value;
+    };
+}

include/lbd/frontend/ast/expression/StringExpression.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <lbd/frontend/ast/expression/Expression.hpp>
+
+namespace lbd::frontend::ast::expression
+{
+    class StringExpression final : Expression
+    {
+    public:
+        StringExpression(const source::Range& range, std::string value) noexcept;
+
+        void print(std::ostream& outputStream, size_t indent) const noexcept override;
+
+    private:
+        std::string value;
+    };
+}

include/lbd/type/Type.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <lbd/type/TypeKind.hpp>
+
+namespace lbd::type
+{
+    class Type;
+    using TypePtr = std::shared_ptr<Type>;
+
+    struct TypePtrHash
+    {
+        size_t operator()(const TypePtr& t) const noexcept;
+    };
+
+    struct TypePtrEq
+    {
+        bool operator()(const TypePtr& a, const TypePtr& b) const noexcept;
+    };
+
+    // Usage: std::unordered_map<TypePtr, TypePtr, TypePtrHash, TypePtrEq> typeSubstitutionMap;
+
+    struct Constraint
+    {
+        std::string className; // Eq, Ord, Show.
+        TypePtr type; // Most likely will be a VARIABLE: a, b.
+
+        [[nodiscard]] bool operator==(const Constraint& other) const noexcept;
+    };
+
+    class Type
+    {
+    public:
+        // Factory functions.
+        [[nodiscard]] static TypePtr named(const std::string& name);
+        [[nodiscard]] static TypePtr variable(const std::string& name);
+        [[nodiscard]] static TypePtr applied(const TypePtr& base, std::vector<TypePtr> arguments);
+        [[nodiscard]] static TypePtr function(const TypePtr& from, const TypePtr& to);
+        [[nodiscard]] static TypePtr qualified(std::vector<Constraint> constraints, const TypePtr& qualifiedType);
+        [[nodiscard]] static TypePtr any();
+
+        // Observers.
+        [[nodiscard]] TypeKind getKind() const noexcept;
+        [[nodiscard]] const std::string& getName() const noexcept;
+        [[nodiscard]] const TypePtr& getBase() const noexcept;
+        [[nodiscard]] const std::vector<TypePtr>& getArguments() const noexcept;
+        [[nodiscard]] const TypePtr& getFrom() const noexcept;
+        [[nodiscard]] const TypePtr& getTo() const noexcept;
+        [[nodiscard]] const std::vector<Constraint>& getConstraints() const noexcept;
+        [[nodiscard]] const TypePtr& getQualifiedType() const noexcept;
+
+        // Comparison.
+        [[nodiscard]] bool equals(const Type& other) const noexcept;
+        [[nodiscard]] bool accepts(const Type& other) const noexcept;
+        [[nodiscard]] bool operator==(const Type& other) const noexcept;
+        [[nodiscard]] size_t hash() const noexcept;
+
+        friend std::ostream& operator<<(std::ostream&, const Type&) noexcept;
+
+    private:
+        TypeKind kind;
+
+        // NAMED, VARIABLE.
+        std::string name;
+
+        // APPLIED.
+        TypePtr base;
+        std::vector<TypePtr> arguments;
+
+        // FUNCTION.
+        TypePtr from;
+        TypePtr to;
+
+        // QUALIFIED.
+        std::vector<Constraint> constraints;
+        TypePtr qualifiedType;
+    };
+}

include/lbd/type/TypeKind.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace lbd::type
+{
+    enum class TypeKind
+    {
+        NAMED, // Number, String
+        VARIABLE, // a, b
+        APPLIED, // List<Number>, Map<String, Number>
+        FUNCTION, // String -> Number
+        QUALIFIED, // Eq a => a -> a
+        ANY,
+    };
+}