catching out of bounds integer literals and division by zero errors

src/CMakeLists.txt

@@ -4,6 +4,7 @@ add_executable(
         lexer.hpp
         lexer.cpp
         token.hpp
+        token.cpp
         overloaded.hpp
         parser.cpp
         parser.hpp

src/runtime_error.hpp

@@ -152,3 +152,14 @@ class NoSuchMember : public RuntimeError {
                   member.lexeme()
           ) } { }
 };
+
+class InvalidIntegerValue final : public RuntimeError {
+public:
+    explicit InvalidIntegerValue(std::string_view const string)
+        : RuntimeError{ std::format("'{}' is not a valid integer", string) } { }
+};
+
+class DivisionByZero final : public RuntimeError {
+public:
+    DivisionByZero() : RuntimeError{ "division by zero" } { }
+};

src/source_location.hpp

@@ -8,7 +8,7 @@
 #include <string_view>
 #include <utility>
 
-class Token;
+struct Token;
 
 struct SourceLocation {
     std::string_view filename;

src/token.cpp

@@ -0,0 +1,14 @@
+#include "token.hpp"
+#include "runtime_error.hpp"
+
+[[nodiscard]] std::int32_t Token::parse_integer() const {
+    assert(type == TokenType::IntegerLiteral);
+    auto stream = std::stringstream{};
+    stream << lexeme();
+    auto result = std::int32_t{};
+    stream >> result;
+    if (not stream) {
+        throw InvalidIntegerValue{ lexeme() };
+    }
+    return result;
+}

src/token.hpp

@@ -46,23 +46,17 @@ struct Token final {
     TokenType type;
     SourceLocation source_location;
 
-    Token(TokenType type, SourceLocation source_location) : type{ type }, source_location{ source_location } { }
+    Token(TokenType const type, SourceLocation const& source_location)
+        : type{ type },
+          source_location{ source_location } { }
 
     [[nodiscard]] std::string_view lexeme() const {
         return source_location.text();
     }
 
-    [[nodiscard]] std::int32_t parse_integer() const {
-        assert(type == TokenType::IntegerLiteral);
-        auto stream = std::stringstream{};
-        stream << lexeme();
-        auto result = std::int32_t{};
-        stream >> result;
-        assert(stream);
-        return result;
-    }
+    [[nodiscard]] std::int32_t parse_integer() const;
 
-    friend std::ostream& operator<<(std::ostream& os, Token token) {
+    friend std::ostream& operator<<(std::ostream& os, Token const& token) {
         switch (token.type) {
             default:
                 assert(false and "unreachable");

src/values/integer.hpp

@@ -135,7 +135,11 @@ namespace values {
             if (not other->is_integer_value()) {
                 return BasicValue::divide(other->clone()); // throws
             }
-            return make(value() / other->as_integer_value().value(), ValueCategory::Rvalue);
+            auto const rhs = other->as_integer_value().value();
+            if (rhs == 0) {
+                throw DivisionByZero{};
+            }
+            return make(value() / rhs, ValueCategory::Rvalue);
         }
 
         [[nodiscard]] Value mod(Value const& other) const override {