refactor(driver): split processPreCompilationOptions into separate steps

Author: Snowy1803

tools/gluc/sources/CompilerDriver.cpp

@@ -245,7 +245,7 @@ void CompilerDriver::printTokens()
     }
 }
 
-bool CompilerDriver::configureParser()
+bool CompilerDriver::configureScanner()
 {
     _fileID.emplace(_sourceManager.loadFile(_config.inputFile));
 
@@ -256,24 +256,31 @@ bool CompilerDriver::configureParser()
     }
 
     _scanner.emplace(_sourceManager.getBuffer(**_fileID));
-
-    _parser.emplace(
-        _scanner.value(), _context.value(), _sourceManager, _diagManager.value()
-    );
     return true;
 }
 
-int CompilerDriver::processPreCompilationOptions()
+int CompilerDriver::runParser()
 {
-    _ast = llvm::cast<glu::ast::ModuleDecl>(_parser->getAST());
+    glu::Parser parser(
+        _scanner.value(), _context.value(), _sourceManager, _diagManager.value()
+    );
+
+    if (!parser.parse() || _diagManager->hasErrors()) {
+        return 1;
+    }
 
-    assert(_ast && "AST should always exist if parse is successful");
+    _ast = llvm::cast<glu::ast::ModuleDecl>(parser.getAST());
 
     if (_config.stage == PrintASTGen) {
         _ast->print(*_outputStream);
         return 0;
     }
 
+    return 0;
+}
+
+int CompilerDriver::runSema()
+{
     sema::constrainAST(
         _ast, *_diagManager, &(*_importManager),
         _config.stage == PrintConstraints
@@ -298,19 +305,27 @@ int CompilerDriver::processPreCompilationOptions()
         return 1;
     }
 
+    return 0;
+}
+
+int CompilerDriver::runGILGen()
+{
     glu::gilgen::GILGen gilgen;
 
-    _gilModule.emplace(gilgen.generateModule(_ast, _GILFuncArena));
+    _gilModule.emplace(gilgen.generateModule(_ast, _gilArena));
 
     if (_config.stage == PrintGILGen) {
         // Print all functions in the generated function list
         _gilPrinter->visit(*_gilModule);
-        return 0;
     }
 
+    return 0;
+}
+
+int CompilerDriver::runOptimizer()
+{
     glu::optimizer::PassManager passManager(
-        *_diagManager, _sourceManager, *_outputStream, *_gilModule,
-        _GILFuncArena
+        *_diagManager, _sourceManager, *_outputStream, *_gilModule, _gilArena
     );
     passManager.runPasses();
 
@@ -323,7 +338,11 @@ int CompilerDriver::processPreCompilationOptions()
     if (_diagManager->hasErrors()) {
         return 1;
     }
+    return 0;
+}
 
+int CompilerDriver::runIRGen()
+{
     glu::irgen::IRGen irgen;
     _llvmModule.emplace(
         _sourceManager.getBufferName(
@@ -502,7 +521,7 @@ int CompilerDriver::executeCompilation(char const *argv0)
     _importManager.emplace(*_context, *_diagManager, _config.importDirs);
 
     // Configure parser
-    if (!configureParser()) {
+    if (!configureScanner()) {
         return 1;
     }
 
@@ -513,20 +532,45 @@ int CompilerDriver::executeCompilation(char const *argv0)
     }
 
     // Parse the source code
-    if (!_parser->parse() || _diagManager->hasErrors()) {
+    if (runParser()) {
         return 1;
     }
 
+    if (_config.stage <= PrintASTGen) {
+        return 0;
+    }
+
     // Process pre-compilation options
-    auto compileResult = processPreCompilationOptions();
+    if (runSema()) {
+        return 1;
+    }
 
-    // Handle early exit cases for print options and bitcode emission
-    if (_config.stage <= EmitBitcode) {
-        return compileResult;
+    if (_config.stage <= PrintAST) {
+        return 0;
+    }
+
+    if (runGILGen()) {
+        return 1;
+    }
+
+    if (_config.stage <= PrintGILGen) {
+        return 0;
+    }
+
+    if (runOptimizer()) {
+        return 1;
+    }
+
+    if (_config.stage <= PrintGIL) {
+        return 0;
+    }
+
+    if (runIRGen()) {
+        return 1;
     }
 
-    if (compileResult != 0) {
-        return compileResult;
+    if (_config.stage <= EmitBitcode) {
+        return 0;
     }
 
     // Verify generated IR

tools/gluc/sources/CompilerDriver.hpp

@@ -74,13 +74,12 @@ class CompilerDriver {
         _diagManager; ///< Handles error/warning reporting
     std::optional<glu::ast::ASTContext>
         _context; ///< AST memory management and context
-    std::optional<glu::Parser> _parser; ///< Parses tokens into AST
     std::optional<glu::Scanner> _scanner; ///< Tokenizes source code
     std::optional<glu::sema::ImportManager>
         _importManager; ///< Handles module imports
 
     // Code generation components
-    llvm::BumpPtrAllocator _GILFuncArena; ///< Memory arena for GIL functions
+    llvm::BumpPtrAllocator _gilArena; ///< Memory arena for GIL functions
     std::optional<glu::gil::GILPrinter>
         _gilPrinter; ///< Prints GIL representation
     llvm::LLVMContext _llvmContext; ///< LLVM context for IR generation
@@ -130,16 +129,32 @@ class CompilerDriver {
 
     /// @brief Configure the parser with loaded source file and create scanner
     /// @return True if successful, false otherwise
-    bool configureParser();
+    bool configureScanner();
 
     /// @brief Print tokens for debugging (when --print-tokens is specified)
     void printTokens();
 
-    /// @brief Process pre-compilation options like AST/GIL/IR printing
+    /// @brief Run the parser to generate the AST
     /// @return Exit code (0 for success, non-zero for error)
-    int processPreCompilationOptions();
+    int runParser();
 
-    /// @brief Perform the main compilation steps (parsing, sema, codegen)
+    /// @brief Run semantic analysis on the AST
+    /// @return Exit code (0 for success, non-zero for error)
+    int runSema();
+
+    /// @brief Run GIL generation from the AST
+    /// @return Exit code (0 for success, non-zero for error)
+    int runGILGen();
+
+    /// @brief Run optimization passes on the GIL module
+    /// @return Exit code (0 for success, non-zero for error)
+    int runOptimizer();
+
+    /// @brief Run LLVM IR generation from the GIL module
+    /// @return Exit code (0 for success, non-zero for error)
+    int runIRGen();
+
+    /// @brief Compile the generated LLVM IR to object code or assembly
     /// @return Exit code (0 for success, non-zero for error)
     int compile();