feat: ready to implement auto forward declaration

Author: tahadostifam

Cargo.lock

@@ -14,6 +14,7 @@ clap = { version = "4.5.41", features = ["derive"] }
 lexer = { path = "../lexer", version = "*" }
 utils = { path = "../utils", version = "*" }
 ast = { path = "../ast", version = "*" }
+typed_ast = { path = "../typed_ast", version = "*" }
 resolver = { path = "../resolver", version = "*" }
 colorized = "1.0.0"
 toml = "0.8.20"

crates/cli/Cargo.toml

@@ -1,46 +1,93 @@
+use crate::CompilerOptions;
 use ast::token::TokenKind;
+use codegen::{context::context::CodeGenContext, options::OutputKind};
+use diagcentral::display_single_cusotm_diag;
 use lexer::Lexer;
+use parser::Parser;
+use resolver::{Resolver, Visiting, generate_module_id, moduleloader::ModuleLoaderOptions};
+use std::{env, mem, process::exit, rc::Rc};
+use typed_ast::TypedProgramTree;
+
+fn get_program_trees(options: &CompilerOptions, file_path: String) -> Vec<(String, Rc<TypedProgramTree>)> {
+    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());
+
+    let node = match parser.parse() {
+        Ok(node) => node,
+        Err(errors) => {
+            parser.display_parser_errors(errors.clone());
+            exit(1);
+        }
+    };
+
+    let module_loader_opts = ModuleLoaderOptions {
+        stdlib_path: options.stdlib.clone(),
+        source_dirs: options.source_dirs.clone(),
+    };
+
+    let mut resolver = Resolver::new(module_loader_opts, file_path.clone());
+    let module_id = generate_module_id();
+    match resolver.resolve_module(module_id, node.as_program(), &mut Visiting::new(), true) {
+        Some(..) => {}
+        None => unreachable!(),
+    };
+    if resolver.reporter.has_errors() {
+        resolver.reporter.display();
+        exit(1);
+    }
 
-use crate::CompilerOptions;
+    let final_program_trees: Vec<(String, Rc<TypedProgramTree>)>;
+    let mut program_trees = resolver.program_trees.lock().unwrap();
+    final_program_trees = mem::take(&mut program_trees);
+    drop(program_trees);
 
-pub(crate) fn command_run(compiler_options: CompilerOptions, file_path: Option<String>) {
-    // let context = CodeGenContext::new(options, output_kind);
-    todo!()
+    final_program_trees
 }
 
-pub(crate) fn command_emit_llvm(
-    compiler_options: CompilerOptions,
-    file_path: Option<String>,
-    output_path: Option<String>,
-) {
-    // let context = CodeGenContext::new(options, output_kind);
-    todo!()
+pub(crate) fn command_run(options: CompilerOptions, file_path: Option<String>) {
+    let context = CodeGenContext::new(options.to_compiler_options(), OutputKind::None);
+
+    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();
+    }
 }
 
-pub(crate) fn command_emit_asm(
-    compiler_options: CompilerOptions,
-    file_path: Option<String>,
-    output_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());
+    });
+
+    let context = CodeGenContext::new(options.to_compiler_options(), OutputKind::LlvmIr(output_path));
+
+    let program_trees = get_program_trees(&options, file_path.unwrap());
+    context.compile_modules(program_trees);
+}
+
+pub(crate) fn command_emit_asm(options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
     // let context = CodeGenContext::new(options, output_kind);
     todo!()
 }
 
-pub(crate) fn command_build(compiler_options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
+pub(crate) fn command_build(options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
     // let context = CodeGenContext::new(options, output_kind);
     todo!()
 }
 
-pub(crate) fn command_object(
-    compiler_options: CompilerOptions,
-    file_path: Option<String>,
-    output_path: Option<String>,
-) {
+pub(crate) fn command_object(options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
     // let context = CodeGenContext::new(options, output_kind);
     todo!()
 }
 
-pub(crate) fn command_dylib(compiler_options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
+pub(crate) fn command_dylib(options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
     // let context = CodeGenContext::new(options, output_kind);
     todo!()
 }
@@ -62,17 +109,17 @@ pub(crate) fn command_lex_only(file_path: String) {
 }
 
 pub(crate) fn command_parse_only(file_path: String) {
-    // let (file_content, file_name) = read_file(file_path.clone());
-    // let mut lexer = Lexer::new(file_content, file_name);
-
-    // match CyrusParser::new(&mut lexer).parse() {
-    //     Ok(result) => println!("{:#?}", result),
-    //     Err(errors) => {
-    //         for err in errors {
-    //             err.print();
-    //         }
-    //     }
-    // }
+    let (file_content, file_name) = utils::fs::read_file(file_path.clone());
+    let mut lexer = Lexer::new(file_content, file_name.clone());
+    let mut parser = Parser::new(lexer.tokenize(), file_name);
+
+    match parser.parse() {
+        Ok(result) => println!("{:#?}", result),
+        Err(errors) => {
+            parser.display_parser_errors(errors.clone());
+            exit(1);
+        }
+    }
 }
 
 pub(crate) fn command_syntactic_only(file_path: String) {

crates/cli/src/commands.rs

@@ -1,12 +1,12 @@
 use clap::{Parser, ValueEnum};
 use codegen::options::{BuildDir, CodeGenOptions, CodeModelOptions, RelocModeOptions};
 use commands::*;
-use compiler::project_file_required;
 use diagcentral::display_single_cusotm_diag;
 use serde::Deserialize;
+use trigger::project_file_required;
 
 mod commands;
-mod compiler;
+mod trigger;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
 enum OptimizeLevel {

crates/cli/src/main.rs

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

crates/cli/src/compiler.rs renamed to crates/cli/src/trigger.rs

@@ -0,0 +1,119 @@
+use super::module::CodeGenBuilder;
+use ast::{AccessSpecifier, SelfModifierKind};
+use inkwell::{
+    AddressSpace,
+    attributes::{Attribute, AttributeLoc},
+    llvm_sys::{
+        core::LLVMFunctionType,
+        prelude::{LLVMBool, LLVMTypeRef},
+    },
+    module::Linkage,
+    types::{AsTypeRef, BasicMetadataTypeEnum, BasicTypeEnum, FunctionType, StructType},
+    values::FunctionValue,
+};
+use typed_ast::{TypedFuncParamKind, TypedFuncParams, types::ConcreteType};
+
+impl<'a> CodeGenBuilder<'a> {
+    pub(crate) fn build_func_decl(
+        &self,
+        func_name: String,
+        params: TypedFuncParams,
+        return_type: ConcreteType,
+        vis: AccessSpecifier,
+        method_struct_type: Option<StructType<'a>>,
+    ) -> FunctionValue<'a> {
+        let linkage = self.build_func_linkage(vis);
+        let fn_type = self.build_func_type(params, return_type, method_struct_type);
+
+        let llvmmodule = self.llvmmodule.borrow();
+        let fn_value = llvmmodule.add_function(&func_name, fn_type, Some(linkage));
+        self.add_func_attrs(fn_value);
+        drop(llvmmodule);
+        fn_value
+    }
+
+    pub(crate) fn add_func_attrs(&self, func: FunctionValue) {
+        let attr_kind_id = |kind: &str| Attribute::get_named_enum_kind_id(kind);
+
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_enum_attribute(attr_kind_id("uwtable"), 2),
+        );
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_enum_attribute(attr_kind_id("ssp"), 0),
+        );
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_enum_attribute(attr_kind_id("nounwind"), 0),
+        );
+
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_string_attribute("frame-pointer", "all"),
+        );
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_string_attribute("no-trapping-math", "true"),
+        );
+        func.add_attribute(
+            AttributeLoc::Function,
+            self.llvmctx.create_string_attribute("stack-protector-buffer-size", "8"),
+        );
+    }
+
+    pub(crate) fn build_func_linkage(&self, vis: AccessSpecifier) -> Linkage {
+        match vis {
+            AccessSpecifier::Extern => Linkage::External,
+            AccessSpecifier::Public => Linkage::External,
+            AccessSpecifier::Internal => Linkage::Private,
+            AccessSpecifier::Inline => Linkage::Internal,
+            AccessSpecifier::PublicInline => Linkage::LinkOnceODR,
+            AccessSpecifier::PublicExtern => Linkage::External,
+        }
+    }
+
+    pub(crate) fn build_func_type(
+        &self,
+        params: TypedFuncParams,
+        return_type: ConcreteType,
+        method_struct_type: Option<StructType<'a>>,
+    ) -> FunctionType<'a> {
+        let param_types: Vec<BasicMetadataTypeEnum<'a>> = params
+            .list
+            .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::SelfModifier(self_modifier) => match self_modifier.kind {
+                        SelfModifierKind::Copied => BasicTypeEnum::StructType(method_struct_type.unwrap()),
+                        SelfModifierKind::Referenced => {
+                            BasicTypeEnum::PointerType(self.llvmctx.ptr_type(AddressSpace::default()))
+                        }
+                    },
+                };
+                BasicMetadataTypeEnum::from(basic_type_enum.clone())
+            })
+            .collect();
+
+        let return_type = self.build_conrete_type(return_type);
+
+        let is_var_args = params.variadic.is_some();
+        let fn_type = unsafe {
+            let mut param_types = param_types
+                .iter()
+                .map(|ty| ty.as_type_ref())
+                .collect::<Vec<LLVMTypeRef>>();
+
+            LLVMFunctionType(
+                return_type.as_type_ref(),
+                param_types.as_mut_ptr(),
+                param_types.len() as u32,
+                is_var_args as LLVMBool,
+            )
+        };
+        unsafe { FunctionType::new(fn_type) }
+    }
+}

crates/codegen/Cargo.toml

@@ -1 +1,4 @@
+mod funcs;
 pub mod module;
+mod stmts;
+mod types;