feat: added literal suffix support and still working on codegen

Author: tahadostifam

crates/ast/src/format.rs

@@ -16,7 +16,13 @@ impl fmt::Display for Identifier {
 impl fmt::Display for Literal {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.kind {
-            LiteralKind::Integer(integer) => write!(f, "{}", integer),
+            LiteralKind::Integer(integer, integer_type_opt) => {
+                write!(f, "{}", integer)?;
+                if let Some(integer_type) = integer_type_opt {
+                    write!(f, "{}", (**integer_type).to_string())?
+                }
+                write!(f, "")
+            }
             LiteralKind::Bool(bool) => write!(f, "{}", bool),
             LiteralKind::String(string_type, prefix) => {
                 if let Some(prefix) = prefix {
@@ -27,7 +33,13 @@ impl fmt::Display for Literal {
                 }
                 write!(f, "\"{}\"", string_type)
             }
-            LiteralKind::Float(float) => write!(f, "{}", float),
+            LiteralKind::Float(float, float_type_opt) => {
+                write!(f, "{}", float)?;
+                if let Some(float_type) = float_type_opt {
+                    write!(f, "{}", (**float_type).to_string())?
+                }
+                write!(f, "")
+            }
             LiteralKind::Char(ch) => write!(f, "{}", ch),
             LiteralKind::Null => write!(f, "null"),
         }

crates/ast/src/lib.rs

@@ -232,10 +232,10 @@ pub struct Literal {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum LiteralKind {
-    Integer(i64),
-    Float(f64),
-    Bool(bool),
+    Integer(i64, Option<Box<TokenKind>>),
+    Float(f64, Option<Box<TokenKind>>),
     String(String, Option<StringPrefix>),
+    Bool(bool),
     Char(char),
     Null,
 }

crates/ast/src/token.rs

@@ -136,6 +136,11 @@ pub const PRIMITIVE_TYPES: &[TokenKind] = &[
     TokenKind::Void,
 ];
 
+#[derive(Debug, Clone)]
+pub enum LiteralSuffix {
+    PrimitiveType(TokenKind)
+}
+
 impl fmt::Display for TokenKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

crates/codegen/src/builder/enums.rs

@@ -0,0 +1,9 @@
+use typed_ast::TypedEnum;
+
+use crate::builder::module::CodeGenBuilder;
+
+impl<'a> CodeGenBuilder<'a> {
+    pub(crate) fn build_enum_def(&self, typed_enum: &TypedEnum) {
+        todo!()
+    }
+}

crates/codegen/src/builder/exprs.rs

@@ -0,0 +1,80 @@
+use crate::builder::module::CodeGenBuilder;
+use ast::{Literal, LiteralKind, token::TokenKind};
+use inkwell::{AddressSpace, types::BasicTypeEnum, values::AnyValueEnum};
+use resolver::scope::LocalScopeRef;
+use typed_ast::{TypedExpression, TypedExpressionKind, TypedLiteral, types::ConcreteType};
+
+#[derive(Debug, Clone)]
+pub struct CodeGenExprValue<'a> {
+    concrete_type: ConcreteType,
+    value: AnyValueEnum<'a>,
+}
+
+impl<'a> CodeGenExprValue<'a> {
+    pub fn lvalue(&self) -> AnyValueEnum<'a> {
+        self.value
+    }
+
+    pub fn rvalue(&self) -> AnyValueEnum<'a> {
+        match &self.concrete_type {
+            ConcreteType::Symbol(_) => todo!(),
+            ConcreteType::Pointer(concrete_type) => {
+                todo!()
+            }
+            ConcreteType::Const(_) => self.value,
+            ConcreteType::Array(_) => self.value,
+            ConcreteType::BasicType(_) => self.value,
+            ConcreteType::UnnamedStruct(_) => self.value,
+        }
+    }
+}
+
+impl<'a> CodeGenBuilder<'a> {
+    pub(crate) fn build_expr(
+        &self,
+        local_scope_opt: Option<LocalScopeRef>,
+        typed_expr: &TypedExpression,
+    ) -> AnyValueEnum<'a> {
+        match &typed_expr.kind {
+            TypedExpressionKind::Symbol(_) => todo!(),
+            TypedExpressionKind::Literal(typed_literal) => self.build_literal(typed_literal),
+            TypedExpressionKind::Prefix(typed_prefix_expression) => todo!(),
+            TypedExpressionKind::Infix(typed_infix_expression) => todo!(),
+            TypedExpressionKind::Unary(typed_unary_expression) => todo!(),
+            TypedExpressionKind::Assignment(typed_assignment) => todo!(),
+            TypedExpressionKind::Cast(typed_cast) => todo!(),
+            TypedExpressionKind::Array(typed_array) => todo!(),
+            TypedExpressionKind::ArrayIndex(typed_array_index) => todo!(),
+            TypedExpressionKind::AddressOf(typed_address_of) => todo!(),
+            TypedExpressionKind::Dereference(typed_dereference) => todo!(),
+            TypedExpressionKind::StructInit(typed_struct_init) => todo!(),
+            TypedExpressionKind::FuncCall(typed_func_call) => todo!(),
+            TypedExpressionKind::FieldAccess(typed_field_access) => todo!(),
+            TypedExpressionKind::MethodCall(typed_method_call) => todo!(),
+            TypedExpressionKind::UnnamedStructValue(typed_unnamed_struct_value) => todo!(),
+        }
+    }
+
+    fn build_literal(&self, literal: &TypedLiteral) -> AnyValueEnum<'a> {
+        let basic_type_enum: BasicTypeEnum<'a> = self.build_basic_concrete_type(literal.ty.clone()).try_into().unwrap();
+
+        match &literal.kind {
+            LiteralKind::Bool(value) => {
+                AnyValueEnum::IntValue(self.llvmctx.bool_type().const_int(*value as u64, false))
+            }
+            LiteralKind::Integer(value, _) => AnyValueEnum::IntValue(
+                basic_type_enum
+                    .into_int_type()
+                    .const_int((*value).try_into().unwrap(), literal.ty.is_signed()),
+            ),
+            LiteralKind::Float(value, _) => {
+                AnyValueEnum::FloatValue(basic_type_enum.into_float_type().const_float(*value))
+            }
+            LiteralKind::Char(value) => AnyValueEnum::IntValue(self.llvmctx.i8_type().const_int(*value as u64, false)),
+            LiteralKind::Null => {
+                AnyValueEnum::PointerValue(self.llvmctx.ptr_type(AddressSpace::default()).const_null())
+            }
+            LiteralKind::String(_, string_prefix) => todo!(),
+        }
+    }
+}

crates/codegen/src/builder/funcs.rs

@@ -11,9 +11,23 @@ use inkwell::{
     types::{AsTypeRef, BasicMetadataTypeEnum, BasicTypeEnum, FunctionType, StructType},
     values::FunctionValue,
 };
-use typed_ast::{TypedFuncParamKind, TypedFuncParams, types::ConcreteType};
+use typed_ast::{TypedFuncDef, TypedFuncParamKind, TypedFuncParams, types::ConcreteType};
 
 impl<'a> CodeGenBuilder<'a> {
+    pub(crate) fn build_func_def(&self, func_def: &TypedFuncDef) {
+        let irreg = self.irreg.borrow();
+        let local_ir_value = irreg.get(&func_def.symbol_id).unwrap();
+
+        let fn_value = local_ir_value.as_func().unwrap();
+
+        let entry_block = self.llvmctx.append_basic_block(*fn_value, "entry");
+        self.llvmbuilder.position_at_end(entry_block);
+
+        self.build_block_statement(&func_def.body);
+
+        drop(irreg);
+    }
+
     pub(crate) fn build_func_decl(
         &self,
         func_name: String,

crates/codegen/src/builder/mod.rs

@@ -1,4 +1,7 @@
+mod enums;
 mod funcs;
 pub mod module;
 mod stmts;
 mod types;
+mod variables;
+mod exprs;

crates/codegen/src/builder/stmts.rs

@@ -1,11 +1,6 @@
 use super::module::{CodeGenBuilder, LocalIRValue};
-use ast::AccessSpecifier;
-use inkwell::{
-    module::Linkage,
-    types::{BasicTypeEnum, StructType},
-    values::GlobalValue,
-};
-use typed_ast::{SymbolID, TypedExpression, TypedFuncDef, TypedGlobalVariable, TypedStatement, TypedStruct};
+use inkwell::types::{BasicTypeEnum, StructType};
+use typed_ast::{SymbolID, TypedBlockStatement, TypedStatement, TypedStruct};
 
 impl<'a> CodeGenBuilder<'a> {
     pub(crate) fn build_toplevel_statements(&self, stmts: &Vec<TypedStatement>) {
@@ -15,7 +10,7 @@ impl<'a> CodeGenBuilder<'a> {
             match stmt {
                 TypedStatement::FuncDef(typed_func_def) => self.build_func_def(typed_func_def),
                 TypedStatement::Struct(typed_struct) => self.build_struct_def(typed_struct),
-                TypedStatement::Enum(typed_enum) => todo!(),
+                TypedStatement::Enum(typed_enum) => self.build_enum_def(typed_enum),
                 TypedStatement::Interface(typed_interface) => todo!(),
                 // already handled in build_forward_decls
                 TypedStatement::GlobalVariable(_) => continue,
@@ -104,53 +99,42 @@ impl<'a> CodeGenBuilder<'a> {
         self.llvmctx.opaque_struct_type(name)
     }
 
-    fn build_global_variable_linkage(&self, vis: AccessSpecifier) -> Linkage {
-        match vis {
-            AccessSpecifier::PublicExtern => Linkage::Common,
-            AccessSpecifier::Extern => Linkage::Common,
-            AccessSpecifier::Public => Linkage::External,
-            AccessSpecifier::Internal => Linkage::Private,
-            AccessSpecifier::Inline => unreachable!(),
-            AccessSpecifier::PublicInline => unreachable!(),
-        }
-    }
-
-    fn build_global_var_decl(&self, global_var: &TypedGlobalVariable) -> GlobalValue<'a> {
-        let linkage = self.build_global_variable_linkage(global_var.vis.clone());
+    pub(crate) fn build_block_statement(&self, block_stmt: &TypedBlockStatement) {
+        let local_scope_opt = Some(
+            self.resolver
+                .get_scope_ref(self.module_id, block_stmt.scope_id)
+                .unwrap(),
+        );
 
-        let mut global_var_type = {
-            if let Some(concrete_type) = &global_var.ty {
-                Some(self.build_concrete_type(None, concrete_type.clone()))
-            } else {
-                None
+        for stmt in &block_stmt.exprs {
+            match stmt {
+                TypedStatement::Variable(typed_variable) => {
+                    self.build_local_variable(local_scope_opt.clone(), typed_variable)
+                }
+                TypedStatement::If(typed_if) => todo!(),
+                TypedStatement::Return(typed_return) => todo!(),
+                TypedStatement::Break(typed_break) => todo!(),
+                TypedStatement::Continue(typed_continue) => todo!(),
+                TypedStatement::For(typed_for) => todo!(),
+                TypedStatement::Foreach(typed_foreach) => todo!(),
+                TypedStatement::Switch(typed_switch) => todo!(),
+                TypedStatement::Struct(typed_struct) => todo!(),
+                TypedStatement::Enum(typed_enum) => todo!(),
+                TypedStatement::Expression(typed_expr) => {
+                    self.build_expr(local_scope_opt.clone(), typed_expr);
+                }
+                TypedStatement::BlockStatement(typed_block_statement) => {
+                    self.build_block_statement(typed_block_statement);
+                }
+                TypedStatement::Interface(typed_interface) => todo!(),
+                // Skipped statements
+                TypedStatement::Typedef(_) => continue,
+                // Invalid statements
+                TypedStatement::FuncDef(_) => unreachable!(),
+                TypedStatement::FuncDecl(_) => unreachable!(),
+                TypedStatement::Import(_) => unreachable!(),
+                TypedStatement::GlobalVariable(_) => unreachable!(),
             }
-        };
-
-        if global_var_type.is_none() {
-            let typed_expr: TypedExpression = global_var.expr.clone().unwrap();
-            global_var_type = Some(self.build_concrete_type(None, typed_expr.concrete_type.unwrap()));
         }
-
-        let global_var_type: BasicTypeEnum<'a> = global_var_type.unwrap().try_into().unwrap();
-
-        let llvmmodule = self.llvmmodule.borrow();
-        let global_var_value = llvmmodule.add_global(global_var_type, None, &global_var.name);
-        global_var_value.set_linkage(linkage);
-        drop(llvmmodule);
-        global_var_value
-    }
-
-    fn build_func_def(&self, func_def: &TypedFuncDef) {
-        let irreg = self.irreg.borrow();
-        let local_ir_value = irreg.get(&func_def.symbol_id).unwrap();
-
-        let fn_value = local_ir_value.as_func().unwrap();
-
-        let entry_block = self.llvmctx.append_basic_block(*fn_value, "entry");
-        self.llvmbuilder.position_at_end(entry_block);
-
-        // TODO build body block
-
-        drop(irreg);
     }
 }

crates/codegen/src/builder/types.rs

@@ -4,16 +4,16 @@ use inkwell::{
     AddressSpace,
     types::{AnyTypeEnum, BasicType, BasicTypeEnum, PointerType},
 };
-use resolver::scope::SymbolEntry;
+use resolver::scope::{LocalScopeRef, SymbolEntry};
 use typed_ast::{
-    ScopeID, SymbolID,
+    SymbolID,
     types::{BasicConcreteType, ConcreteType, TypedArrayCapacity},
 };
 
 impl<'a> CodeGenBuilder<'a> {
     pub(crate) fn build_concrete_type_from_symbol_id(
         &self,
-        local_scope_opt: Option<ScopeID>,
+        local_scope_opt: Option<LocalScopeRef>,
         symbol_id: SymbolID,
     ) -> AnyTypeEnum<'a> {
         if let Some(local_scope) = local_scope_opt {
@@ -52,7 +52,7 @@ impl<'a> CodeGenBuilder<'a> {
 
     pub(crate) fn build_concrete_type(
         &self,
-        local_scope_opt: Option<ScopeID>,
+        local_scope_opt: Option<LocalScopeRef>,
         concrete_type: ConcreteType,
     ) -> AnyTypeEnum<'a> {
         match concrete_type {
@@ -80,7 +80,7 @@ impl<'a> CodeGenBuilder<'a> {
                     .fields
                     .iter()
                     .map(|field| {
-                        self.build_concrete_type(local_scope_opt, *field.field_type.clone())
+                        self.build_concrete_type(local_scope_opt.clone(), *field.field_type.clone())
                             .try_into()
                             .unwrap()
                     })

crates/codegen/src/builder/variables.rs

@@ -0,0 +1,68 @@
+use crate::builder::module::CodeGenBuilder;
+use ast::AccessSpecifier;
+use inkwell::{module::Linkage, types::BasicTypeEnum, values::{BasicValueEnum, GlobalValue}};
+use resolver::scope::LocalScopeRef;
+use typed_ast::{TypedExpression, TypedGlobalVariable, TypedVariable};
+
+impl<'a> CodeGenBuilder<'a> {
+    pub(crate) fn build_global_var_decl(&self, global_var: &TypedGlobalVariable) -> GlobalValue<'a> {
+        let linkage = self.build_global_variable_linkage(global_var.vis.clone());
+
+        let mut global_var_type = {
+            if let Some(concrete_type) = &global_var.ty {
+                Some(self.build_concrete_type(None, concrete_type.clone()))
+            } else {
+                None
+            }
+        };
+
+        if global_var_type.is_none() {
+            let typed_expr: TypedExpression = global_var.expr.clone().unwrap();
+            global_var_type = Some(self.build_concrete_type(None, typed_expr.concrete_type.unwrap()));
+        }
+
+        let global_var_type: BasicTypeEnum<'a> = global_var_type.unwrap().try_into().unwrap();
+
+        let llvmmodule = self.llvmmodule.borrow();
+        let global_var_value = llvmmodule.add_global(global_var_type, None, &global_var.name);
+        global_var_value.set_linkage(linkage);
+        drop(llvmmodule);
+        global_var_value
+    }
+
+    fn build_global_variable_linkage(&self, vis: AccessSpecifier) -> Linkage {
+        match vis {
+            AccessSpecifier::PublicExtern => Linkage::Common,
+            AccessSpecifier::Extern => Linkage::Common,
+            AccessSpecifier::Public => Linkage::External,
+            AccessSpecifier::Internal => Linkage::Private,
+            AccessSpecifier::Inline => unreachable!(),
+            AccessSpecifier::PublicInline => unreachable!(),
+        }
+    }
+
+    pub(crate) fn build_local_variable(&self, local_scope_opt: Option<LocalScopeRef>, variable: &TypedVariable) {
+        let var_type: BasicTypeEnum<'a> = {
+            if let Some(concrete_type) = &variable.ty {
+                self.build_concrete_type(local_scope_opt.clone(), concrete_type.clone())
+                    .try_into()
+                    .unwrap()
+            } else {
+                self.build_concrete_type(
+                    local_scope_opt.clone(),
+                    variable.rhs.clone().unwrap().concrete_type.unwrap(),
+                )
+                .try_into()
+                .unwrap()
+            }
+        };
+
+        let alloca = self.llvmbuilder.build_alloca(var_type, &variable.name).unwrap();
+        if let Some(typed_expr) = &variable.rhs {
+            let rvalue: BasicValueEnum<'a> = self.build_expr(local_scope_opt, typed_expr).try_into().unwrap();
+            // TODO
+            // let rvalue = self.implicit_cast();
+            self.llvmbuilder.build_store(alloca, rvalue).unwrap();
+        }
+    }
+}