feat: implement literal characters

CMakeLists.txt

@@ -20,6 +20,7 @@ add_library(
   source/ast/builtin_function_expression.cpp
   source/ast/callable_expression.cpp
   source/ast/call_expression.cpp
+  source/ast/character_literal.cpp
   source/ast/function_expression.cpp
   source/ast/hash_literal_expression.cpp
   source/ast/identifier.cpp

source/ast/character_literal.cpp

@@ -0,0 +1,11 @@
+#include "character_literal.hpp"
+
+character_literal::character_literal(char val)
+    : value(val)
+{
+}
+
+auto character_literal::string() const -> std::string
+{
+    return {1, value};
+}

source/ast/character_literal.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "expression.hpp"
+
+struct character_literal : expression
+{
+    explicit character_literal(char val);
+    [[nodiscard]] auto string() const -> std::string override;
+    [[nodiscard]] auto eval(environment_ptr env) const -> object override;
+    auto compile(compiler& comp) const -> void override;
+
+    char value;
+};

source/compiler/ast_compile.cpp

@@ -14,6 +14,7 @@
 #include <code/code.hpp>
 #include <eval/object.hpp>
 
+#include "ast/character_literal.hpp"
 #include "compiler.hpp"
 #include "symbol_table.hpp"
 
@@ -219,3 +220,8 @@ auto call_expression::compile(compiler& comp) const -> void
 }
 
 auto builtin_function_expression::compile(compiler& /*comp*/) const -> void {}
+
+auto character_literal::compile(compiler& comp) const -> void
+{
+    comp.emit(opcodes::constant, comp.add_constant({value}));
+}

source/compiler/compiler.cpp

@@ -215,7 +215,7 @@ auto check_program(std::string_view input) -> parsed_program
     return {std::move(prgrm), std::move(prsr)};
 }
 
-using expected_value = std::variant<int64_t, std::string, std::vector<instructions>>;
+using expected_value = std::variant<int64_t, char, std::string, std::vector<instructions>>;
 
 struct ctc
 {
@@ -240,6 +240,7 @@ auto check_constants(const std::vector<expected_value>& expecteds, const constan
         std::visit(
             overloaded {
                 [&](const int64_t val) { CHECK_EQ(val, actual.as<integer_type>()); },
+                [&](const char val) { CHECK_EQ(val, actual.as<char>()); },
                 [&](const std::string& val) { CHECK_EQ(val, actual.as<string_type>()); },
                 [&](const std::vector<instructions>& instrs)
                 { check_instructions(instrs, actual.as<compiled_function>().instrs); },
@@ -485,6 +486,23 @@ TEST_CASE("stringExpression")
             },
         },
     };
+    run(std::move(tests));
+}
+
+TEST_CASE("characterExpression")
+{
+    using enum opcodes;
+    std::array tests {
+        ctc {
+            R"('m')",
+            {{'m'}},
+            {
+                make(constant, 0),
+                make(pop),
+            },
+        },
+    };
+    run(std::move(tests));
 }
 
 TEST_CASE("arrayLiterals")