Upgrade gcc, clang, boost

Author: Jeff-Mott-OR

CMakeLists.txt

@@ -15,15 +15,15 @@ set(BOOST_INCLUDE_LIBRARIES algorithm convert process program_options test)
 FetchContent_Declare(
     Boost
     GIT_REPOSITORY https://github.com/boostorg/boost.git
-    GIT_TAG boost-1.80.0
+    GIT_TAG boost-1.83.0
     GIT_SHALLOW ON
 )
 
 set(BENCHMARK_ENABLE_TESTING FALSE)
 FetchContent_Declare(
     Google_Benchmark
     GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG v1.7.1
+    GIT_TAG v1.8.3
     GIT_SHALLOW ON
 )
 
@@ -36,7 +36,7 @@ FetchContent_Declare(
 
 FetchContent_Declare(
     Crafting_Interpreters
-    URL https://github.com/munificent/craftinginterpreters/archive/d2800ebca6ab6d56f698ad0eef8202a91821eb04.zip
+    URL https://github.com/munificent/craftinginterpreters/archive/01e6f5b8f3e5dfa65674c2f9cf4700d73ab41cf8.zip
 )
 
 FetchContent_MakeAvailable(Boost Google_Benchmark Microsoft_GSL Crafting_Interpreters)

Dockerfile

@@ -1,16 +1,24 @@
-ARG CC=gcc
+ARG CC=clang
 
 FROM ubuntu:22.04 AS base
 
-    RUN apt update && apt install -y cmake git ninja-build
+    RUN apt update && apt install -y cmake git ninja-build software-properties-common
 
 FROM base AS base-clang
 
-    RUN apt update && apt install -y clang
+    RUN apt update && apt install -y gpg lsb-release wget
+    RUN wget https://apt.llvm.org/llvm.sh
+    RUN chmod +x llvm.sh
+    RUN ./llvm.sh 17
+    ENV CC=clang-17
+    ENV CXX=clang++-17
 
 FROM base AS base-gcc
 
-    RUN apt update && apt install -y build-essential
+    RUN add-apt-repository ppa:ubuntu-toolchain-r/test
+    RUN apt update && apt install -y g++-13
+    ENV CC=gcc-13
+    ENV CXX=g++-13
 
 FROM base-$CC AS deps
 

README.md

@@ -79,7 +79,7 @@ When targeting `bench`, use Docker's `--progress=plain` option to see the result
 
     --build-arg CC=<compiler>
 
-The compiler can be one of: `gcc` or `clang`. Defaults to `gcc`.
+The compiler can be one of: `gcc` or `clang`. Defaults to `clang`.
 
 ## Use REPL in container shell
 

src/chunk.cpp

@@ -52,12 +52,12 @@ namespace motts::lox
         reinterpret_cast<std::uint16_t&>(bytecode_.at(jump_begin_index_ - 2)) = jump_distance_big_endian;
     }
 
-    Chunk::Constants_vector::size_type Chunk::insert_constant(Dynamic_type_value value)
+    std::size_t Chunk::insert_constant(Dynamic_type_value value)
     {
         const auto maybe_duplicate_iter = std::find(constants_.cbegin(), constants_.cend(), value);
         if (maybe_duplicate_iter != constants_.cend()) {
             const auto constant_index = maybe_duplicate_iter - constants_.cbegin();
-            return gsl::narrow<Constants_vector::size_type>(constant_index);
+            return gsl::narrow<std::size_t>(constant_index);
         }
 
         const auto constant_index = constants_.size();
@@ -221,7 +221,7 @@ namespace motts::lox
         os << "Bytecode:\n";
         for (auto bytecode_iter = chunk.bytecode().cbegin(); bytecode_iter != chunk.bytecode().cend();) {
             const auto bytecode_index = bytecode_iter - chunk.bytecode().cbegin();
-            const auto source_map_token = chunk.source_map_tokens().at(bytecode_index);
+            const auto& source_map_token = chunk.source_map_tokens().at(bytecode_index);
             const auto opcode = static_cast<Opcode>(*bytecode_iter++);
 
             // Some opcodes such as closure will print multiple lines.

src/chunk.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
 #include <ostream>
 #include <vector>
 
@@ -102,7 +103,7 @@ namespace motts::lox
             void to_next_opcode();
         };
 
-        Constants_vector::size_type insert_constant(Dynamic_type_value);
+        std::size_t insert_constant(Dynamic_type_value);
 
       public:
         // Read-only access.

src/compiler.cpp

@@ -10,13 +10,9 @@
 #include "object.hpp"
 #include "scanner.hpp"
 
-// Not exported (internal linkage).
-namespace
+namespace motts::lox
 {
-    // Allow the internal linkage section to access names.
-    using namespace motts::lox;
-
-    void ensure_token_is(const Token& token, Token_type expected)
+    static void ensure_token_is(const Token& token, Token_type expected)
     {
         if (token.type != expected) {
             std::ostringstream os;
@@ -256,9 +252,7 @@ namespace
 
                     (*(function_chunks.end() - 2))
                         ->chunk.emit_closure(
-                            gc_heap.make<Function>(
-                                {interned_strings.get(std::string_view{""}), param_count, std::move(function_chunk.chunk)}
-                            ),
+                            gc_heap.make<Function>({interned_strings.get(""), param_count, std::move(function_chunk.chunk)}),
                             function_chunk.tracked_upvalues,
                             fun_token
                         );
@@ -937,10 +931,7 @@ namespace
             }
         }
     };
-}
 
-namespace motts::lox
-{
     Chunk compile(GC_heap& gc_heap, Interned_strings& interned_strings, std::string_view source)
     {
         return Compiler{gc_heap, interned_strings, source}.compile();

src/interned_strings.cpp

@@ -8,9 +8,7 @@ namespace motts::lox
         gc_heap_.on_destroy_ptr.push_back([this](const auto& control_block) {
             const auto maybe_gc_str_iter = strings_by_ptr_.find(&control_block);
             if (maybe_gc_str_iter != strings_by_ptr_.cend()) {
-                const auto gc_str = maybe_gc_str_iter->second;
-
-                strings_by_chars_.erase(*gc_str);
+                strings_by_chars_.erase(*maybe_gc_str_iter->second);
                 strings_by_ptr_.erase(maybe_gc_str_iter);
             }
         });
@@ -21,6 +19,11 @@ namespace motts::lox
         gc_heap_.on_destroy_ptr.pop_back();
     }
 
+    GC_ptr<const std::string> Interned_strings::get(const char* str)
+    {
+        return get(std::string_view{str});
+    }
+
     GC_ptr<const std::string> Interned_strings::get(std::string_view str)
     {
         const auto maybe_dup_iter = strings_by_chars_.find(str);

src/interned_strings.hpp

@@ -18,6 +18,7 @@ namespace motts::lox
         Interned_strings(GC_heap&);
         ~Interned_strings();
 
+        GC_ptr<const std::string> get(const char*);
         GC_ptr<const std::string> get(std::string_view);
         GC_ptr<const std::string> get(std::string&&);
     };

src/memory.cpp

@@ -37,10 +37,9 @@ namespace motts::lox
 
         const auto not_marked_begin =
             std::partition(all_ptrs_.begin(), all_ptrs_.end(), [](const auto* control_block) { return control_block->marked; });
-
         std::for_each(not_marked_begin, all_ptrs_.end(), [&](const auto* control_block) {
-            for (const auto& fn : on_destroy_ptr) {
-                fn(*control_block);
+            for (const auto& on_destroy_fn : on_destroy_ptr) {
+                on_destroy_fn(*control_block);
             }
 
             n_allocated_bytes_ -= control_block->size();

src/memory.hpp

@@ -8,13 +8,13 @@ namespace motts::lox
 {
     class GC_heap;
 
-    // Every garbage collect-able object can be polymorphically "marked" and trace references.
+    // Every garbage collect-able object can be polymorphically marked and trace references.
     struct GC_control_block_base
     {
         bool marked{false};
 
         virtual ~GC_control_block_base() = default;
-        virtual void trace_refs(GC_heap&) = 0;
+        virtual void trace_refs(GC_heap&) const = 0;
         virtual std::size_t size() const = 0;
     };
 
@@ -39,7 +39,7 @@ namespace motts::lox
         {
         }
 
-        void trace_refs(GC_heap& gc_heap) override
+        void trace_refs(GC_heap& gc_heap) const override
         {
             trace_refs_trait(gc_heap, value);
         }
@@ -149,14 +149,11 @@ namespace motts::lox
 }
 
 // The hash of GC_ptrs is the hash of the underlying control block pointers.
-namespace std
+template<typename User_value_type>
+struct std::hash<motts::lox::GC_ptr<User_value_type>>
 {
-    template<typename User_value_type>
-    struct hash<motts::lox::GC_ptr<User_value_type>>
+    std::size_t operator()(motts::lox::GC_ptr<User_value_type> gc_ptr) const
     {
-        std::size_t operator()(motts::lox::GC_ptr<User_value_type> gc_ptr) const
-        {
-            return std::hash<motts::lox::GC_control_block_base*>{}(gc_ptr.control_block);
-        }
-    };
-}
+        return std::hash<motts::lox::GC_control_block_base*>{}(gc_ptr.control_block);
+    }
+};

src/object.cpp

@@ -33,10 +33,10 @@ namespace motts::lox
     void trace_refs_trait(GC_heap& gc_heap, const Closure& closure)
     {
         mark(gc_heap, closure.function);
-        for (const auto& upvalue : closure.upvalues) {
+        for (const GC_ptr<Upvalue> upvalue : closure.upvalues) {
             mark(gc_heap, upvalue);
         }
-        for (const auto& upvalue : closure.open_upvalues) {
+        for (const GC_ptr<Upvalue> upvalue : closure.open_upvalues) {
             mark(gc_heap, upvalue);
         }
     }
@@ -45,7 +45,7 @@ namespace motts::lox
     void trace_refs_trait(GC_heap& gc_heap, const Function& function)
     {
         mark(gc_heap, function.name);
-        for (const auto& value : function.chunk.constants()) {
+        for (const Dynamic_type_value value : function.chunk.constants()) {
             std::visit(Mark_objects_visitor{gc_heap}, value);
         }
         for (const auto& source_map_token : function.chunk.source_map_tokens()) {
@@ -68,7 +68,7 @@ namespace motts::lox
         }
     }
 
-    Upvalue::Upvalue(std::vector<Dynamic_type_value>& stack_arg, std::vector<Dynamic_type_value>::size_type stack_index_arg)
+    Upvalue::Upvalue(std::vector<Dynamic_type_value>& stack_arg, std::size_t stack_index_arg)
         : value_{Open{stack_arg, stack_index_arg}}
     {
     }
@@ -79,7 +79,7 @@ namespace motts::lox
         value_ = Closed{open.stack.at(open.stack_index)};
     }
 
-    std::vector<Dynamic_type_value>::size_type Upvalue::stack_index() const
+    std::size_t Upvalue::stack_index() const
     {
         return std::get<Open>(value_).stack_index;
     }
@@ -90,7 +90,7 @@ namespace motts::lox
             return std::get<Closed>(value_).value;
         }
 
-        const auto& open = std::get<Open>(value_);
+        const auto open = std::get<Open>(value_);
         return open.stack.at(open.stack_index);
     }
 

src/object.hpp

@@ -33,8 +33,8 @@ namespace motts::lox
     struct Closure
     {
         GC_ptr<Function> function;
-        // An upvalue refers to a local variable in an enclosing function that the closure uses.
         std::vector<GC_ptr<Upvalue>> upvalues;
+
         // Following Lua, we’ll use "open upvalue" to refer to an upvalue that points to a local variable still on the stack.
         std::vector<GC_ptr<Upvalue>> open_upvalues;
 
@@ -77,7 +77,7 @@ namespace motts::lox
             // These two fields can be thought of as an iterator into the stack,
             // but iterators can be invalidated, so instead keep a stack reference and index.
             std::vector<Dynamic_type_value>& stack;
-            const std::vector<Dynamic_type_value>::size_type stack_index;
+            const std::size_t stack_index;
         };
 
         struct Closed
@@ -88,10 +88,10 @@ namespace motts::lox
         std::variant<Open, Closed> value_;
 
       public:
-        Upvalue(std::vector<Dynamic_type_value>& stack, std::vector<Dynamic_type_value>::size_type stack_index);
+        Upvalue(std::vector<Dynamic_type_value>& stack, std::size_t stack_index);
 
         void close();
-        std::vector<Dynamic_type_value>::size_type stack_index() const;
+        std::size_t stack_index() const;
         const Dynamic_type_value& value() const;
         Dynamic_type_value& value();
     };

src/value.cpp

@@ -2,12 +2,8 @@
 
 #include "object.hpp"
 
-// Not exported (internal linkage).
-namespace
+namespace motts::lox
 {
-    // Allow the internal linkage section to access names.
-    using namespace motts::lox;
-
     struct Print_visitor
     {
         std::ostream& os;
@@ -67,10 +63,7 @@ namespace
             os << *str;
         }
     };
-}
 
-namespace motts::lox
-{
     std::ostream& operator<<(std::ostream& os, Dynamic_type_value value)
     {
         std::visit(Print_visitor{os}, value);