Integration and fixes

.github/workflows/ci_tests.yml

@@ -1,6 +1,6 @@
 name: "CI tests"
 
-on: [ push, workflow_dispatch ]
+on: [push, workflow_dispatch]
 
 jobs:
   build-matrix:
@@ -11,22 +11,31 @@ jobs:
       matrix:
         config:
           - {
-            name: "Windows Latest MSVC", artifact: "Windows-MSVC.tar.xz",
-            os: windows-latest,
-            build_type: "Release", cc: "cl", cxx: "cl",
-            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat"
-          }
+              name: "Windows Latest MSVC",
+              artifact: "Windows-MSVC.tar.xz",
+              os: windows-latest,
+              build_type: "Release",
+              cc: "cl",
+              cxx: "cl",
+              environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat",
+            }
           - {
-            name: "Ubuntu Latest GCC", artifact: "Linux.tar.xz",
-            os: ubuntu-latest,
-            build_type: "Release", cc: "gcc", cxx: "g++"
-          }
+              name: "Ubuntu Latest GCC",
+              artifact: "Linux.tar.xz",
+              os: ubuntu-latest,
+              build_type: "Release",
+              cc: "gcc",
+              cxx: "g++",
+            }
           - {
-            name: "macOS Latest Clang", artifact: "macOS.tar.xz",
-            os: macos-latest,
-            build_type: "Release", cc: "clang", cxx: "clang++"
-          }
-
+              name: "macOS Latest Clang",
+              artifact: "macOS.tar.xz",
+              os: macos-latest,
+              build_type: "Release",
+              cc: "clang",
+              cxx: "clang++",
+            }
+
     steps:
       - uses: actions/checkout@v4
 
@@ -196,7 +205,7 @@ jobs:
           echo "Running clang-tidy-19 on ${#files[@]} files..."
           # Use clang-tidy-19 for better C++23 support and --extra-arg-before to ensure C++23 standard is set before other flags
           clang-tidy-19 "${files[@]}" -p cmake-build-tidy --format-style=file > tidy_output.txt 2>&1 || true
-          
+
           # Ensure file exists and is readable
           if [ ! -f tidy_output.txt ]; then
             echo "" > tidy_output.txt
@@ -213,11 +222,11 @@ jobs:
             errors=$(grep -c "error:" tidy_output.txt 2>/dev/null || echo "0")
             warnings=$(grep -c "warning:" tidy_output.txt 2>/dev/null || echo "0")
           fi
-          
+
           # Ensure we have clean integer values
           errors=$(echo "$errors" | tr -d '\n' | head -c 10)
           warnings=$(echo "$warnings" | tr -d '\n' | head -c 10)
-          
+
           # Default to 0 if empty or non-numeric
           errors=${errors:-0}
           warnings=${warnings:-0}
@@ -227,6 +236,12 @@ jobs:
 
           echo "Found $errors errors and $warnings warnings"
 
+          if [ "$errors" -eq 0 ] && [ "$warnings" -le 3 ]; then
+            echo "clang-tidy found $warnings warnings"
+            cat tidy_output.txt
+            exit 0
+          fi
+
           # Fail if more than 3 warnings or any errors
           if [ "$errors" -gt 0 ] || [ "$warnings" -gt 3 ]; then
             echo "clang-tidy found $errors errors and $warnings warnings"
@@ -240,7 +255,7 @@ jobs:
         with:
           script: |
             const fs = require('fs');
-            
+
             try {
               let comment = '## 🔍 Code Quality Issues Found\n\n';
 

cmake/IncludeExternalLibraries.cmake

@@ -12,6 +12,17 @@ FetchContent_Declare(
 
 FetchContent_MakeAvailable(googletest)
 
+
+# ArgParser
+FetchContent_Declare(
+    argparser
+    GIT_REPOSITORY https://github.com/bialger/ArgParser.git
+    GIT_TAG v1.3.5
+)
+
+FetchContent_MakeAvailable(argparser)
+
+
 # Ovum Common
 FetchContent_Declare(
     ovumcommon

lib/compiler_ui/CMakeLists.txt

@@ -6,6 +6,8 @@ add_library(compiler_ui STATIC
 target_link_libraries(compiler_ui PUBLIC
         lexer
         preprocessor
+        parser
+        argparser
 )
 
 target_include_directories(compiler_ui PUBLIC ${PROJECT_SOURCE_DIR})

lib/compiler_ui/compiler_ui_functions.cpp

@@ -1,31 +1,114 @@
+#include "argparser/Argument.hpp"
 #include "compiler_ui_functions.hpp"
 
+#include <fstream>
+#include <memory>
+
+#include <argparser/ArgParser.hpp>
+
+#include "lib/parser/ParserFsm.hpp"
+#include "lib/parser/ast/BuilderAstFactory.hpp"
+#include "lib/parser/ast/visitors/BytecodeVisitor.hpp"
+#include "lib/parser/ast/visitors/LintVisitor.hpp"
+#include "lib/parser/ast/visitors/TypeChecker.hpp"
+#include "lib/parser/diagnostics/DiagnosticCollector.hpp"
+#include "lib/parser/pratt/DefaultOperatorResolver.hpp"
+#include "lib/parser/pratt/PrattExpressionParser.hpp"
+#include "lib/parser/tokens/token_streams/VectorTokenStream.hpp"
+#include "lib/parser/type_parser/QNameTypeParser.hpp"
 #include "lib/preprocessor/Preprocessor.hpp"
 
+static void PrintDiagnosticMessage(const ovum::compiler::parser::Diagnostic& diag, std::ostream& out) {
+  if (diag.IsSuppressed()) {
+    return;
+  }
+
+  std::string severity_str = diag.GetSeverity() ? diag.GetSeverity()->Name().data() : "UNKNOWN";
+
+  out << "[" << severity_str << "]";
+
+  if (!diag.GetCode().empty()) {
+    out << " " << diag.GetCode();
+  }
+
+  out << ": " << diag.GetDiagnosticsMessage();
+  const std::optional<ovum::compiler::parser::SourceSpan>& where_opt = diag.GetWhere();
+
+  if (where_opt.has_value()) {
+    const ovum::compiler::parser::SourceSpan& where = where_opt.value();
+
+    if (!where.GetSourceId().Path().empty()) {
+      out << " \nAt " << where.GetSourceId().Path();
+    }
+
+    if (where.GetStart() == where.GetEnd()) {
+      out << " line " << where.GetStart().GetLine() << " column " << where.GetStart().GetColumn();
+    } else {
+      out << " from line " << where.GetStart().GetLine() << " column " << where.GetStart().GetColumn() << " to line "
+          << where.GetEnd().GetLine() << " column " << where.GetEnd().GetColumn();
+    }
+  }
+
+  out << "\n";
+}
+
 int32_t StartCompilerConsoleUI(const std::vector<std::string>& args, std::ostream& out, std::ostream& err) {
-  if (args.size() < 2) {
-    err << "Usage: ovumc <main_file.ovum> [include_path1] [include_path2] ...\n";
-    err << "Example: ovumc sample.ovum /path/to/includes\n";
+  const CompositeString default_output_name = "Same as input file but with .oil extension";
+  auto is_file = [](std::string& arg) { return std::filesystem::exists(arg); };
+  auto is_directory = [](std::string& arg) { return std::filesystem::is_directory(arg); };
+  std::string description = "Ovum Compiler that compiles Ovum source code to Ovum Intermediate Language.";
+  std::vector<CompositeString> include_dirs;
+  std::vector<std::string> define_symbols;
+  std::vector<bool> no_lint;
+
+  ArgumentParser::ArgParser arg_parser("ovumc", PassArgumentTypes());
+  arg_parser.AddCompositeArgument('m', "main-file", "Path to the main file").AddIsGood(is_file).AddValidate(is_file);
+  arg_parser.AddCompositeArgument('o', "output-file", "Path to the output file").Default(default_output_name);
+  arg_parser.AddCompositeArgument('I', "include-dirs", "Path to directories where include files are located")
+      .AddIsGood(is_directory)
+      .AddValidate(is_directory)
+      .MultiValue(0)
+      .StoreValues(include_dirs);
+  arg_parser.AddStringArgument('D', "define-symbols", "Defined symbols").MultiValue(0).StoreValues(define_symbols);
+  arg_parser.AddFlag('n', "no-lint", "Disable linter").MultiValue(0).StoreValues(no_lint);
+  arg_parser.AddHelp('h', "help", description);
+
+  bool parse_result = arg_parser.Parse(args, {.out_stream = err, .print_messages = true});
+  if (!parse_result) {
+    err << arg_parser.HelpDescription();
     return 1;
   }
 
-  if (args[1] == "--help") {
-    out << "Usage: ovumc <main_file.ovum> [include_path1] [include_path2] ...\n";
-    out << "Example: ovumc sample.ovum /path/to/includes\n";
+  if (arg_parser.Help()) {
+    out << arg_parser.HelpDescription();
     return 0;
   }
 
-  std::filesystem::path main_file = args[1];
-  std::set<std::filesystem::path> include_paths;
+  std::filesystem::path main_file = arg_parser.GetCompositeValue("main-file").c_str();
+  std::filesystem::path output_file;
+  const CompositeString& output_file_value = arg_parser.GetCompositeValue("output-file");
 
-  include_paths.emplace(main_file.parent_path());
+  if (output_file_value == default_output_name) {
+    output_file = main_file;
+    output_file.replace_extension(".oil");
+  } else {
+    output_file = output_file_value.c_str();
+  }
 
-  for (size_t i = 2; i < args.size(); ++i) {
-    include_paths.emplace(args[i]);
+  std::set<std::filesystem::path> include_paths;
+
+  for (const auto& include_dir : include_dirs) {
+    include_paths.emplace(include_dir.c_str());
   }
 
   std::unordered_set<std::string> predefined_symbols;
 
+  for (const auto& define_symbol : define_symbols) {
+    predefined_symbols.emplace(define_symbol.c_str());
+  }
+
+  include_paths.emplace(main_file.parent_path());
+
   ovum::compiler::preprocessor::PreprocessingParameters params{
       .include_paths = include_paths, .predefined_symbols = predefined_symbols, .main_file = main_file};
 
@@ -35,16 +118,64 @@ int32_t StartCompilerConsoleUI(const std::vector<std::string>& args, std::ostrea
 
   if (!result) {
     err << result.error().what() << "\n";
-    return 1;
+    return 2;
+  }
+
+  std::vector<ovum::TokenPtr> tokens = std::move(result.value());
+
+  // Set up parser
+  auto factory = std::make_shared<ovum::compiler::parser::BuilderAstFactory>();
+  auto type_parser = std::make_unique<ovum::compiler::parser::QNameTypeParser>(*factory);
+  auto resolver = std::make_unique<ovum::compiler::parser::DefaultOperatorResolver>();
+  auto expr_parser =
+      std::make_unique<ovum::compiler::parser::PrattExpressionParser>(std::move(resolver), factory, type_parser.get());
+  auto parser =
+      std::make_unique<ovum::compiler::parser::ParserFsm>(std::move(expr_parser), std::move(type_parser), factory);
+
+  // Parse
+  ovum::compiler::parser::DiagnosticCollector diags;
+  ovum::compiler::parser::VectorTokenStream stream(tokens);
+  auto module = parser->Parse(stream, diags);
+
+  if (!module) {
+    err << "Parsing failed\n";
+    return 3;
+  }
+
+  // Linting
+  if (no_lint.empty() || !no_lint[0]) {
+    ovum::compiler::parser::LintVisitor lint_visitor(diags);
+    module->Accept(lint_visitor);
+  }
+
+  // Type checking
+  if (no_lint.size() <= 1 || !no_lint[1]) {
+    ovum::compiler::parser::TypeChecker type_checker(diags);
+    module->Accept(type_checker);
   }
 
-  const auto& tokens = result.value();
+  // Check all diagnostics
+  if (diags.Count() > 0) {
+    for (const auto& diag : diags.All()) {
+      PrintDiagnosticMessage(diag, out);
+    }
 
-  for (const auto& t : tokens) {
-    out << t->ToString() << "\n";
+    if (diags.ErrorCount() > 0) {
+      return 4;
+    }
   }
 
-  out << "\nPreprocessed " << tokens.size() << " tokens successfully.\n";
+  // Generate bytecode
+  std::ofstream output_stream(output_file, std::ios::out | std::ios::trunc);
+  if (!output_stream.is_open()) {
+    err << "Failed to open output file: " << output_file.string() << "\n";
+    return 1;
+  }
+
+  ovum::compiler::parser::BytecodeVisitor visitor(output_stream);
+  module->Accept(visitor);
+
+  output_stream.close();
 
   return 0;
 }