chore: update fmt to 11.0.2 (#105)

cmake/fmt.cmake

@@ -2,7 +2,7 @@ include(FetchContent)
 
 FetchContent_Declare(fmt
     GIT_REPOSITORY https://github.com/fmtlib/fmt.git
-    GIT_TAG 8.1.1
+    GIT_TAG 11.0.2
 )
 
 FetchContent_MakeAvailable(fmt)

source/ast/callable_expression.cpp

@@ -1,6 +1,7 @@
 #include "callable_expression.hpp"
 
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 
 callable_expression::callable_expression(std::vector<std::string> params)
     : parameters {std::move(params)}

source/ast/function_expression.cpp

@@ -1,6 +1,7 @@
 #include "function_expression.hpp"
 
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 
 function_expression::function_expression(std::vector<std::string>&& parameters, statement* body)
     : callable_expression(std::move(parameters))

source/ast/hash_literal_expression.cpp

@@ -4,6 +4,7 @@
 #include "hash_literal_expression.hpp"
 
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 
 auto hash_literal_expression::string() const -> std::string
 {

source/ast/util.hpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 
 template<typename Expression>
 auto join(const std::vector<Expression*>& nodes, std::string_view sep = {}) -> std::string

source/code/code.hpp

@@ -46,6 +46,11 @@ enum class opcodes : uint8_t
 
 auto operator<<(std::ostream& ostream, opcodes opcode) -> std::ostream&;
 
+template<>
+struct fmt::formatter<opcodes> : ostream_formatter
+{
+};
+
 using operands = std::vector<size_t>;
 using instructions = std::vector<uint8_t>;
 

source/compiler/compiler.cpp

@@ -9,6 +9,8 @@
 #include <chungus.hpp>
 #include <code/code.hpp>
 #include <doctest/doctest.h>
+#include <fmt/ranges.h>
+#include <overloaded.hpp>
 #include <parser/parser.hpp>
 
 #include "eval/object.hpp"

source/compiler/symbol_table.cpp

@@ -29,13 +29,18 @@ auto operator<<(std::ostream& ost, symbol_scope scope) -> std::ostream&
     return ost;
 }
 
+template<>
+struct fmt::formatter<symbol_scope> : ostream_formatter
+{
+};
+
 auto operator<<(std::ostream& ost, const symbol& sym) -> std::ostream&
 {
     return ost << fmt::format("symbol{{{}, {}, {}}}", sym.name, sym.scope, sym.index);
 }
 
 symbol_table::symbol_table(symbol_table* outer)
-    : m_parent(std::move(outer))
+    : m_parent(outer)
 {
 }
 
@@ -44,7 +49,7 @@ auto symbol_table::define(const std::string& name) -> symbol
     using enum symbol_scope;
     return m_store[name] = symbol {
                .name = name,
-               .scope = m_parent ? local : global,
+               .scope = (m_parent != nullptr) ? local : global,
                .index = m_defs++,
            };
 }
@@ -73,7 +78,7 @@ auto symbol_table::resolve(const std::string& name) -> std::optional<symbol>
     if (m_store.contains(name)) {
         return m_store[name];
     }
-    if (m_parent) {
+    if (m_parent != nullptr) {
         auto maybe_symbol = m_parent->resolve(name);
         if (!maybe_symbol.has_value()) {
             return maybe_symbol;

source/eval/ast_eval.cpp

@@ -18,7 +18,9 @@
 #include <ast/unary_expression.hpp>
 #include <chungus.hpp>
 #include <doctest/doctest.h>
+#include <fmt/ranges.h>
 #include <lexer/token_type.hpp>
+#include <overloaded.hpp>
 #include <parser/parser.hpp>
 
 #include "environment.hpp"
@@ -364,7 +366,8 @@ const builtin_function_expression builtin_len {
         }
         return make_error("argument of type {} to len() is not supported", maybe_string_or_array->type());
     }};
-const builtin_function_expression builtin_puts {{"puts"},
+
+const builtin_function_expression builtin_puts {"puts",
                                                 {"str"},
                                                 [](const array_object::array& arguments) -> const object*
                                                 {

source/eval/object.cpp

@@ -8,6 +8,8 @@
 #include <ast/callable_expression.hpp>
 #include <fmt/format.h>
 #include <fmt/ostream.h>
+#include <fmt/ranges.h>
+#include <overloaded.hpp>
 
 auto operator<<(std::ostream& ostrm, object::object_type type) -> std::ostream&
 {
@@ -57,7 +59,7 @@ auto integer_object::hash_key() const -> hash_key_type
 
 auto builtin_object::inspect() const -> std::string
 {
-    return fmt::format("builtin {}(){{...}}", builtin->name);
+    return fmt::format("builtin {}({}){{...}}", builtin->name, fmt::join(builtin->parameters, ", "));
 }
 
 auto function_object::inspect() const -> std::string
@@ -80,8 +82,6 @@ auto array_object::inspect() const -> std::string
     return strm.str();
 }
 
-namespace
-{
 auto operator<<(std::ostream& strm, const hashable_object::hash_key_type& t) -> std::ostream&
 {
     std::visit(
@@ -94,8 +94,6 @@ auto operator<<(std::ostream& strm, const hashable_object::hash_key_type& t) ->
     return strm;
 }
 
-}  // namespace
-
 auto hash_object::inspect() const -> std::string
 {
     std::stringstream strm;

source/eval/object.hpp

@@ -15,15 +15,6 @@
 
 #include "eval/environment.hpp"
 
-// helper type for std::visit
-template<typename... T>
-struct overloaded : T...
-{
-    using T::operator()...;
-};
-template<class... T>
-overloaded(T...) -> overloaded<T...>;
-
 struct object
 {
     enum class object_type : std::uint8_t
@@ -71,6 +62,11 @@ struct object
 
 auto operator<<(std::ostream& ostrm, object::object_type type) -> std::ostream&;
 
+template<>
+struct fmt::formatter<object::object_type> : ostream_formatter
+{
+};
+
 struct hashable_object : object
 {
     using hash_key_type = std::variant<int64_t, std::string, bool>;
@@ -80,6 +76,8 @@ struct hashable_object : object
     [[nodiscard]] virtual auto hash_key() const -> hash_key_type = 0;
 };
 
+auto operator<<(std::ostream& strm, const hashable_object::hash_key_type& t) -> std::ostream&;
+
 struct integer_object : hashable_object
 {
     explicit integer_object(int64_t val)

source/lexer/token_type.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
+#include <cstdint>
 #include <ostream>
 
 #include <fmt/ostream.h>
 
-enum class token_type
+enum class token_type : std::uint8_t
 {
     // special tokens
     illegal,
@@ -56,3 +57,8 @@ enum class token_type
 };
 
 auto operator<<(std::ostream& ostream, token_type type) -> std::ostream&;
+
+template<>
+struct fmt::formatter<token_type> : ostream_formatter
+{
+};

source/overloaded.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+// helper type for std::visit
+template<typename... T>
+struct overloaded : T...
+{
+    using T::operator()...;
+};
+template<class... T>
+overloaded(T...) -> overloaded<T...>;

source/parser/parser.cpp

@@ -22,7 +22,9 @@
 #include <doctest/doctest.h>
 #include <eval/object.hpp>
 #include <fmt/core.h>
+#include <fmt/ranges.h>
 #include <lexer/token.hpp>
+#include <overloaded.hpp>
 
 namespace
 {

source/vm/vm.cpp

@@ -12,6 +12,8 @@
 #include <doctest/doctest.h>
 #include <eval/object.hpp>
 #include <fmt/core.h>
+#include <fmt/ranges.h>
+#include <overloaded.hpp>
 #include <parser/parser.hpp>
 
 vm::vm(frames frames, const constants* consts, constants* globals)