feat(parser): add error handling, keyword matching, and diagnostics

Add comprehensive error handling to the parser with emit_error(), synchronize_statement(), and error collection methods. Introduce keyword matching capability for proper token validation. Add diagnostic collection for parse errors with source line context. Refactor parse_variable_declaration to use StatementNode return type and proper error handling for missing identifiers, colons, types, and literals.

Author: Reim-developer

wheel_parser/parser.cxx

@@ -1,18 +1,25 @@
 #include "wheel_parser/parser.hxx"
-#include "include/wheel_parser/ast/nodes.hxx"
+#include "wheel_parser/ast/keywords.hxx"
+#include "wheel_parser/ast/nodes.hxx"
+#include <utility>
 #include <wheel_utils/logging.hxx>
 
 using wheel_memory::Arena;
 using wheel_parser::WheelParser;
 using wheel_parser::ast::VariableDeclaration;
+using wheel_parser::ast::StatementNode;
+using wheel_parser::ast::ErrorStatement;
 using wheel_parser::ast::LiteralExpression;
 using wheel_lexer::Lexer;
+using wheel_parser::ast::k_keywords;
 
-WheelParser::WheelParser(Lexer &lexer, Arena &arena, StringInterner &interner) noexcept : 
-                        m_lexer(lexer), m_arena(arena),
-                        m_interner(interner) {
-
-}
+#if defined(WHEEL_EXPERIMENT) && defined(WHEEL_SMALL_VEC)
+WheelParser::WheelParser(Lexer &lexer, Arena &arena, StringInterner &interner) noexcept :
+    m_lexer(lexer), m_arena(arena), m_interner(interner), m_errors(&arena) {}
+#else
+WheelParser::WheelParser(Lexer &lexer, Arena &arena, StringInterner &interner) noexcept :
+    m_lexer(lexer), m_arena(arena), m_interner(interner), m_errors() {}
+#endif
 
 const Token& WheelParser::consume() noexcept {
     const Token& consumed = m_current_token;
@@ -21,12 +28,47 @@ const Token& WheelParser::consume() noexcept {
     return consumed;
 }
 
-bool WheelParser::str_matches(string_view str) noexcept {
-      return m_current_token.str == str;
+bool WheelParser::token_matches(TokenKind token_kind) const noexcept {
+    return m_current_token.kind == token_kind;
 }
 
-bool WheelParser::token_matches(TokenKind token_kind) noexcept {
-    return m_current_token.kind == token_kind;
+bool WheelParser::keyword_matches(Keyword keyword) const noexcept {
+    if (m_current_token.kind != TokenKind::IDENT) {
+        return false;
+    }
+
+    return m_current_token.str == k_keywords[static_cast<size_t>(keyword)].text;
+}
+
+void WheelParser::skip_spaces() noexcept {
+    while (true) {
+        consume();
+        if (m_current_token.kind != TokenKind::SPACE && m_current_token.kind != TokenKind::TAB) {
+            break;
+        }
+    }
+}
+
+void WheelParser::synchronize_statement() noexcept {
+    while (m_current_token.kind != TokenKind::EOF_ && m_current_token.kind != TokenKind::NEWLINE) {
+        consume();
+    }
+}
+
+StatementNode *WheelParser::emit_error(
+    ParseErrorCode code
+) noexcept {
+    const auto *token = copy_token();
+    const auto error = make_parse_error(
+        code,
+        token,
+        token->kind,
+        m_lexer.get_source_location(*token)
+    );
+    m_errors.push_back(error);
+
+    synchronize_statement();
+    return m_arena.allocate<ErrorStatement>(token);
 }
 
 const Token *WheelParser::copy_token() const noexcept {
@@ -38,49 +80,89 @@ const Token *WheelParser::copy_token() const noexcept {
     );
 }
 
-// TODO: Implement error reporting, avoid returning `nullptr`
-// We also need to improve error handling and avoid assuming everything is literal.
-VariableDeclaration *WheelParser::parse_variable_declaration() noexcept {
+StatementNode *WheelParser::parse_variable_declaration() noexcept {
     consume();
+    if (!keyword_matches(Keyword::Var)) {
+        return nullptr;
+    }
+
     const auto start_token = copy_token();
 
-    if (token_matches(TokenKind::IDENT) && str_matches("int")) {
-        while (true) {
-            consume();
-            if (m_current_token.kind != TokenKind::SPACE) break;
-        }
+    skip_spaces();
 
-        const auto var_type = m_interner.intern("int");
-        const auto var_name = m_interner.intern(m_current_token.str);
+    if (!token_matches(TokenKind::IDENT)) {
+        return emit_error(ParseErrorCode::ExpectedIdentifier);
+    }
+    const auto var_name = m_interner.intern(m_current_token.str);
 
-        while(true) {
-            consume();
-            if (m_current_token.kind != TokenKind::SPACE) break;
-        }
+    skip_spaces();
+    if (!token_matches(TokenKind::COLON)) {
+        return emit_error(ParseErrorCode::ExpectedColon);
+    }
 
-        const auto var_operator = m_current_token;
-        if (var_operator.kind != TokenKind::EQUAL) {
-            return nullptr;
-        }
+    skip_spaces();
+    if (!token_matches(TokenKind::IDENT)) {
+        return emit_error(ParseErrorCode::ExpectedType);
+    }
 
-        while(true) {
-            consume();
-            if (m_current_token.kind != TokenKind::SPACE) break;
-        }
+    const auto var_type = m_interner.intern(m_current_token.str);
 
-        const auto var_value = m_interner.intern(m_current_token.str);
-        const auto literal = m_arena.allocate<LiteralExpression>(
-            &m_current_token
-        );
+    skip_spaces();
+    if (!token_matches(TokenKind::EQUAL)) {
+        return emit_error(ParseErrorCode::ExpectedEqual);
+    }
 
-        return m_arena.allocate<VariableDeclaration>(
-            start_token,
-            var_type, var_name, literal
-        );
+    skip_spaces();
+    switch (m_current_token.kind) {
+        case TokenKind::INT_LITERAL:
+        case TokenKind::FLOAT_LITERAL:
+        case TokenKind::STRING_LITERAL:
+        case TokenKind::RAW_STRING_LITERAL:
+            break;
+        default:
+            return emit_error(ParseErrorCode::ExpectedLiteral);
     }
 
-    return nullptr;
+    const auto literal_token = copy_token();
+    const auto literal = m_arena.allocate<LiteralExpression>(
+        literal_token
+    );
+
+    return m_arena.allocate<VariableDeclaration>(
+        start_token,
+        var_type, var_name, literal
+    );
 }
 
 void WheelParser::parse() noexcept {
 }
+
+size_t WheelParser::error_count() const noexcept {
+    return m_errors.size();
+}
+
+const wheel_parser::ParseError *WheelParser::errors_data() const noexcept {
+    return m_errors.data();
+}
+
+void WheelParser::clear_errors() noexcept {
+    m_errors.clear();
+}
+
+wheel_parser::ParseDiagnosticList WheelParser::collect_diagnostics(std::string_view file_name) const {
+    #if defined(WHEEL_EXPERIMENT) && defined(WHEEL_SMALL_VEC)
+        ParseDiagnosticList diagnostics(&m_arena);
+    #else
+        ParseDiagnosticList diagnostics;
+        diagnostics.reserve(m_errors.size());
+    #endif
+
+    const auto *errors = m_errors.data();
+
+    for (size_t index = 0; index < m_errors.size(); ++index) {
+        const auto line_view = m_lexer.get_source_line(errors[index].location.offset);
+        diagnostics.push_back(build_parse_diagnostic(errors[index], line_view, file_name));
+    }
+
+    return ParseDiagnosticList(std::move(diagnostics));
+}