feat: basic forward declaration works now

Author: tahadostifam

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 codegen = { path = "../codegen", version = "*" }
+static_analyzer = { path = "../static_analyzer", version = "*" }
 project_layout = { path = "../project_layout", version = "*" }
 parser = { path = "../parser", version = "*" }
 serde = { version = "1.0.219", features = ["derive"] }

crates/cli/Cargo.toml

@@ -1,14 +1,18 @@
 use crate::CompilerOptions;
 use ast::token::TokenKind;
 use codegen::{context::context::CodeGenContext, options::OutputKind};
-use diagcentral::display_single_cusotm_diag;
+use diagcentral::{display_single_custom_diag, reporter::DiagReporter};
 use lexer::Lexer;
 use parser::Parser;
 use resolver::{Resolver, Visiting, generate_module_id, moduleloader::ModuleLoaderOptions};
-use std::{cell::RefCell, env, mem, process::exit, rc::Rc};
-use typed_ast::TypedProgramTree;
-
-fn get_program_trees(options: &CompilerOptions, file_path: String) -> Vec<(String, Rc<RefCell<TypedProgramTree>>)> {
+use static_analyzer::context::AnalysisContext;
+use std::{cell::RefCell, env, process::exit, rc::Rc};
+use typed_ast::{ModuleID, TypedProgramTree};
+
+fn get_program_trees(
+    options: &CompilerOptions,
+    file_path: String,
+) -> (Vec<(String, ModuleID, Rc<RefCell<TypedProgramTree>>)>, Rc<Resolver>) {
     let file_content = utils::fs::read_file(file_path.clone()).0;
     let mut lexer = Lexer::new(file_content, file_path.clone());
     let mut parser = Parser::new(lexer.tokenize(), file_path.clone());
@@ -37,24 +41,36 @@ fn get_program_trees(options: &CompilerOptions, file_path: String) -> Vec<(Strin
         exit(1);
     }
 
-    let final_program_trees: Vec<(String, Rc<RefCell<TypedProgramTree>>)>;
+    let final_program_trees: Vec<(String, ModuleID, Rc<RefCell<TypedProgramTree>>)>;
     let program_trees = resolver.program_trees.lock().unwrap();
+
+    {
+        for (_, _, typed_program_tree) in program_trees.iter() {
+            let mut typed_program_tree_borrowed = typed_program_tree.borrow_mut();
+            let mut analyzer = AnalysisContext::new(&resolver, module_id, &mut typed_program_tree_borrowed);
+            analyzer.analyze();
+            if analyzer.reporter.has_errors() {
+                DiagReporter::display(&analyzer.reporter);
+                exit(1);
+            }
+        }
+    }
     final_program_trees = program_trees.clone();
     drop(program_trees);
 
-    final_program_trees
+    (final_program_trees, Rc::new(resolver))
 }
 
 pub(crate) fn command_run(options: CompilerOptions, file_path: Option<String>) {
-    let context = CodeGenContext::new(options.to_compiler_options(), OutputKind::None);
+    let (program_trees, resolver_rc) = get_program_trees(&options, file_path.unwrap());
+
+    let context = CodeGenContext::new(options.to_compiler_options(), OutputKind::None, resolver_rc);
+    context.compile_modules(program_trees);
 
     let mut temp = env::temp_dir();
     temp.push("path");
     let temp_file_path = temp.to_str().unwrap().to_string();
 
-    let program_trees = get_program_trees(&options, file_path.unwrap());
-    context.compile_modules(program_trees);
-
     context.emit_exec(temp_file_path.clone());
     if temp.exists() {
         std::fs::remove_file(temp_file_path).unwrap();
@@ -63,12 +79,16 @@ pub(crate) fn command_run(options: CompilerOptions, file_path: Option<String>) {
 
 pub(crate) fn command_emit_llvm(options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
     let output_path = output_path.unwrap_or_else(|| {
-        display_single_cusotm_diag!("Output directory must be specified to generate llvm-ir.".to_string());
+        display_single_custom_diag!("Output directory must be specified to generate llvm-ir.".to_string());
     });
 
-    let context = CodeGenContext::new(options.to_compiler_options(), OutputKind::LlvmIr(output_path));
+    let (program_trees, resolver_rc) = get_program_trees(&options, file_path.unwrap());
 
-    let program_trees = get_program_trees(&options, file_path.unwrap());
+    let context = CodeGenContext::new(
+        options.to_compiler_options(),
+        OutputKind::LlvmIr(output_path),
+        resolver_rc,
+    );
     context.compile_modules(program_trees);
 }
 

crates/cli/src/commands.rs

@@ -1,7 +1,7 @@
 use clap::{Parser, ValueEnum};
 use codegen::options::{BuildDir, CodeGenOptions, CodeModelOptions, RelocModeOptions};
 use commands::*;
-use diagcentral::display_single_cusotm_diag;
+use diagcentral::display_single_custom_diag;
 use serde::Deserialize;
 use trigger::project_file_required;
 
@@ -260,7 +260,7 @@ fn command_new(project_name: String, lib: bool) {
     };
 
     if let Err(err) = result {
-        display_single_cusotm_diag!(err);
+        display_single_custom_diag!(err);
     }
 }
 

crates/cli/src/main.rs

@@ -2,7 +2,7 @@ use codegen::{
     context::context::CodeGenContext,
     options::{CodeGenOptions, OutputKind},
 };
-use diagcentral::display_single_cusotm_diag;
+use diagcentral::display_single_custom_diag;
 
 const PROJECT_FILE_PATH: &str = "Project.toml";
 
@@ -88,6 +88,6 @@ pub fn get_codegen_context(
 
 pub(crate) fn project_file_required() {
     if !std::path::Path::new(PROJECT_FILE_PATH).exists() {
-        display_single_cusotm_diag!(format!("'{}' not found in current directory.", PROJECT_FILE_PATH));
+        display_single_custom_diag!(format!("'{}' not found in current directory.", PROJECT_FILE_PATH));
     }
 }

crates/cli/src/trigger.rs

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 utils = { path = "../utils", version = "*" }
 typed_ast = { path = "../typed_ast", version = "*" }
+resolver = { path = "../resolver", version = "*" }
 ast = { path = "../ast", version = "*" }
 diagcentral = { path = "../diagcentral", version = "*" }
 inkwell = { version = "0.5.0", features = ["llvm18-0"] }

crates/codegen/Cargo.toml

@@ -84,9 +84,10 @@ impl<'a> CodeGenBuilder<'a> {
             .iter()
             .map(|param| {
                 let basic_type_enum: BasicTypeEnum<'a> = match param {
-                    TypedFuncParamKind::FuncParam(typed_func_param) => {
-                        self.build_conrete_type(typed_func_param.ty.clone()).try_into().unwrap()
-                    }
+                    TypedFuncParamKind::FuncParam(typed_func_param) => self
+                        .build_concrete_type(None, typed_func_param.ty.clone())
+                        .try_into()
+                        .unwrap(),
                     TypedFuncParamKind::SelfModifier(self_modifier) => match self_modifier.kind {
                         SelfModifierKind::Copied => BasicTypeEnum::StructType(method_struct_type.unwrap()),
                         SelfModifierKind::Referenced => {
@@ -98,7 +99,7 @@ impl<'a> CodeGenBuilder<'a> {
             })
             .collect();
 
-        let return_type = self.build_conrete_type(return_type);
+        let return_type = self.build_concrete_type(None, return_type);
 
         let is_var_args = params.variadic.is_some();
         let fn_type = unsafe {

crates/codegen/src/builder/funcs.rs

@@ -1,15 +1,17 @@
 use crate::options::CodeGenOptions;
-use diagcentral::display_single_cusotm_diag;
+use diagcentral::display_single_custom_diag;
 use inkwell::{
     OptimizationLevel,
     builder::Builder,
     context::Context,
     module::Module,
     targets::{CodeModel, InitializationConfig, RelocMode, Target, TargetMachine, TargetTriple},
-    values::{FunctionValue, GlobalValue, StructValue},
+    types::StructType,
+    values::{FunctionValue, GlobalValue},
 };
+use resolver::Resolver;
 use std::{cell::RefCell, collections::HashMap, path::Path, rc::Rc};
-use typed_ast::TypedProgramTree;
+use typed_ast::{ModuleID, TypedProgramTree};
 use utils::fs::ensure_output_dir;
 
 pub struct CodeGenModule<'module> {
@@ -19,11 +21,13 @@ pub struct CodeGenModule<'module> {
 }
 
 pub(crate) struct CodeGenBuilder<'a> {
+    pub module_id: ModuleID,
     pub llvmmodule: Rc<RefCell<Module<'a>>>,
     pub llvmbuilder: Builder<'a>,
     pub llvmctx: &'a Context,
     pub llvmtm: TargetMachine,
     pub irreg: LocalIRValueRegistryRef<'a>,
+    pub resolver: Rc<Resolver>,
 }
 
 impl<'module> CodeGenModule<'module> {
@@ -37,7 +41,12 @@ impl<'module> CodeGenModule<'module> {
         }
     }
 
-    pub fn codegen<'a>(&'a self, module_name: String) -> CodeGenModuleOutput<'a> {
+    pub fn codegen<'a>(
+        &'a self,
+        resolver_rc: Rc<Resolver>,
+        module_id: ModuleID,
+        module_name: String,
+    ) -> CodeGenModuleOutput<'a> {
         let llvmmodule = self.ctx.create_module(&module_name);
         let builder = self.ctx.create_builder();
         let llvmtm = self.get_target_machine(
@@ -53,11 +62,13 @@ impl<'module> CodeGenModule<'module> {
         let llvmmodule = Rc::new(RefCell::new(llvmmodule));
 
         let codegen_builder = CodeGenBuilder {
+            module_id,
             llvmmodule: llvmmodule.clone(),
             llvmbuilder: builder,
             llvmctx: &self.ctx,
             llvmtm,
             irreg,
+            resolver: resolver_rc,
         };
 
         let program_tree_borrowed = self.program_tree.borrow();
@@ -98,7 +109,7 @@ impl<'module> CodeGenModule<'module> {
         ) {
             Some(target_machine) => target_machine,
             None => {
-                display_single_cusotm_diag!(
+                display_single_custom_diag!(
                     "Failed to create LLVM Target Machine with given target_triple, cpu, features.".to_string()
                 );
             }
@@ -145,5 +156,28 @@ pub type LocalIRValueRegistry<'a> = HashMap<LocalIRValueID, LocalIRValue<'a>>;
 pub enum LocalIRValue<'a> {
     Func(FunctionValue<'a>),
     GlobalValue(GlobalValue<'a>),
-    Struct(StructValue<'a>),
+    Struct(StructType<'a>),
+}
+
+impl<'a> LocalIRValue<'a> {
+    pub fn as_func(&self) -> Option<&FunctionValue<'a>> {
+        match self {
+            LocalIRValue::Func(func) => Some(func),
+            _ => None,
+        }
+    }
+
+    pub fn as_global_value(&self) -> Option<&GlobalValue<'a>> {
+        match self {
+            LocalIRValue::GlobalValue(global_value) => Some(global_value),
+            _ => None,
+        }
+    }
+
+    pub fn as_struct(&self) -> Option<&StructType<'a>> {
+        match self {
+            LocalIRValue::Struct(struct_type) => Some(struct_type),
+            _ => None,
+        }
+    }
 }