implemeted global const define and genric bug fix

Author: nynrathod

crates/doo_analysis/src/semantic/exhaustiveness.rs

@@ -198,6 +198,7 @@ impl<'a> ExhaustivenessChecker<'a> {
     /// Check a single item.
     fn check_item(&mut self, item: &HirItem) {
         match item {
+            HirItem::Const(_) => {}
             HirItem::Function(func) => self.check_function(func),
             HirItem::Struct(_) | HirItem::Enum(_) | HirItem::Import(_) | HirItem::Policy(_) | HirItem::Interface(_) => {}
         }

crates/doo_analysis/src/semantic/scope.rs

@@ -41,6 +41,8 @@ pub enum SymbolKind {
     Import,
     /// Loop variable (for-in).
     LoopVar,
+    /// Compile-time constant.
+    Const,
 }
 
 /// A single scope with its symbols.

crates/doo_analysis/src/semantic/type_check.rs

@@ -13,8 +13,8 @@ use doo_core::{
     Span,
 };
 use doo_hir::{
-    HirBinOp, HirExpr, HirExprKind, HirFunction, HirItem, HirMatchPattern, HirProgram, HirStmt,
-    HirStmtKind,
+    ConstValue, HirBinOp, HirExpr, HirExprKind, HirFunction, HirItem, HirMatchPattern,
+    HirProgram, HirStmt, HirStmtKind,
 };
 
 /// Type checking error.
@@ -198,6 +198,38 @@ impl TypeChecker {
         self.scopes.enter_scope(super::scope::ScopeKind::Global);
         for item in &program.items {
             match item {
+                HirItem::Const(c) => {
+                    // Detect duplicate const names
+                    if self.scopes.lookup(&c.name).is_some() {
+                        self.errors.push(TypeError {
+                            kind: TypeErrorKind::InvalidOp(format!(
+                                "constant '{}' is already defined",
+                                c.name
+                            )),
+                            span: c.span,
+                        });
+                    } else {
+                        // Validate that the value is a compile-time constant expression
+                        if !is_const_evaluable(&c.value_expr) {
+                            self.errors.push(TypeError {
+                                kind: TypeErrorKind::InvalidOp(format!(
+                                    "const '{}' must be assigned a compile-time constant value \
+                                     (literal, const arithmetic, array/map of literals)",
+                                    c.name
+                                )),
+                                span: c.span,
+                            });
+                        }
+                        self.define_symbol(Symbol {
+                            name: c.name.clone(),
+                            kind: SymbolKind::Const,
+                            type_id: Some(c.type_id),
+                            mutable: false,
+                            span: c.span,
+                            used: false,
+                        });
+                    }
+                }
                 HirItem::Function(func) => {
                     let return_type = func.return_type.unwrap_or(builtin::VOID);
 
@@ -2356,3 +2388,27 @@ impl TypeChecker {
         expected_type
     }
 }
+
+/// Check whether a HIR expression is a valid compile-time constant expression.
+///
+/// Allowed:
+/// - Literal values (Int, Float, Bool, Str, Nil)
+/// - Negation of a literal
+/// - Arithmetic/comparison of two const-evaluable expressions
+/// - Arrays where all elements are const-evaluable
+/// - Maps where all keys and values are const-evaluable
+/// - Const references (already inlined by HIR lowering, appear as Const nodes)
+fn is_const_evaluable(expr: &HirExpr) -> bool {
+    match &expr.kind {
+        HirExprKind::Const(_) => true,
+        HirExprKind::UnaryOp { operand, .. } => is_const_evaluable(operand),
+        HirExprKind::BinOp { lhs, rhs, .. } => {
+            is_const_evaluable(lhs) && is_const_evaluable(rhs)
+        }
+        HirExprKind::Array(elements) => elements.iter().all(is_const_evaluable),
+        HirExprKind::Map(pairs) => pairs
+            .iter()
+            .all(|(k, v)| is_const_evaluable(k) && is_const_evaluable(v)),
+        _ => false,
+    }
+}

crates/doo_codegen/src/builder.rs

@@ -9,7 +9,7 @@ use doo_core::constants::ffi_names::{self, derive_ffi_symbol};
 use doo_core::doo_debug;
 use doo_core::types::{builtin, TypeKind, TypeRegistry};
 use doo_mir::sym::resolve;
-use doo_mir::{MirConst, MirFunction, MirOperand, MirProgram, MirTerminator};
+use doo_mir::{MirConst, MirFunction, MirGlobal, MirOperand, MirProgram, MirTerminator};
 use inkwell::basic_block::BasicBlock;
 use inkwell::context::Context;
 use inkwell::module::{Linkage, Module};
@@ -458,6 +458,11 @@ impl<'ctx> CodegenBuilder<'ctx> {
             }
         }
 
+        // Emit LLVM global constants from MirGlobal entries (primitive consts)
+        for global in &mir.globals {
+            self.emit_global(&mut ctx, global);
+        }
+
         // First pass: declare all functions
         for func in &mir.functions {
             self.declare_function(&mut ctx, func);
@@ -471,6 +476,57 @@ impl<'ctx> CodegenBuilder<'ctx> {
         ctx.module
     }
 
+    /// Emit a single LLVM global constant from a `MirGlobal`.
+    ///
+    /// Primitive consts (Int, Float, Bool, Str) become LLVM global constants with
+    /// internal linkage. The value is stored in the context locals map so that
+    /// `operand_to_value` can resolve `MirOperand::Global(name)` if needed.
+    fn emit_global(&self, ctx: &mut CodegenContext<'ctx>, global: &MirGlobal) {
+        use inkwell::module::Linkage;
+
+        let name = resolve(global.name);
+        let value = match &global.value {
+            Some(v) => v,
+            None => return,
+        };
+
+        match value {
+            MirConst::Int(v) => {
+                // Store the i64 constant value directly as a temp — no LLVM global needed
+                // since constants are inlined. The global is for cross-module visibility.
+                let ty = ctx.context.i64_type();
+                let g = ctx.module.add_global(ty, None, &name);
+                g.set_initializer(&ty.const_int(*v as u64, true));
+                g.set_constant(true);
+                g.set_linkage(Linkage::Internal);
+                // Also cache the raw i64 value so operand_to_value returns it directly
+                ctx.set_temp(&name, ty.const_int(*v as u64, true).into());
+            }
+            MirConst::Float(v) => {
+                let ty = ctx.context.f64_type();
+                let g = ctx.module.add_global(ty, None, &name);
+                g.set_initializer(&ty.const_float(*v));
+                g.set_constant(true);
+                g.set_linkage(Linkage::Internal);
+                ctx.set_temp(&name, ty.const_float(*v).into());
+            }
+            MirConst::Bool(v) => {
+                let ty = ctx.context.i8_type();
+                let g = ctx.module.add_global(ty, None, &name);
+                g.set_initializer(&ty.const_int(*v as u64, false));
+                g.set_constant(true);
+                g.set_linkage(Linkage::Internal);
+                ctx.set_temp(&name, ty.const_int(*v as u64, false).into());
+            }
+            MirConst::Str(s) => {
+                if let Ok(g) = ctx.builder.build_global_string_ptr(s, &name) {
+                    ctx.set_temp(&name, g.as_pointer_value().into());
+                }
+            }
+            MirConst::Nil => {}
+        }
+    }
+
     /// Pre-declare all struct types from the type registry.
     /// This ensures struct types are cached before we try to access their fields.
     fn declare_struct_types(&self, ctx: &mut CodegenContext<'ctx>) {

crates/doo_core/src/errors/codes.rs

@@ -45,6 +45,7 @@ pub enum ErrorCode {
     ExpectedExprAfterOp,    // E0023
     InvalidMatchSyntax,     // E0024
     InvalidForSyntax,       // E0025
+    InvalidConstExpr,       // E0026 — const must be a compile-time literal expression
 
     // === Type Errors (E0100-E0199) ===
     TypeMismatch,            // E0100
@@ -105,6 +106,7 @@ pub enum ErrorCode {
     ContinueOutsideLoop,    // E0419
     ReturnOutsideFunction,  // E0420
     DuplicateMethod,        // E0421  — duplicate method in interface
+    DuplicateConst,         // E0422  — duplicate const declaration
 
     // === Import Errors (E0500-E0599) ===
     ModuleNotFound,    // E0500
@@ -177,6 +179,7 @@ impl ErrorCode {
             Self::ExpectedExprAfterOp => "E0023",
             Self::InvalidMatchSyntax => "E0024",
             Self::InvalidForSyntax => "E0025",
+            Self::InvalidConstExpr => "E0026",
 
             Self::TypeMismatch => "E0100",
             Self::UnknownType => "E0101",
@@ -232,6 +235,7 @@ impl ErrorCode {
             Self::ContinueOutsideLoop => "E0419",
             Self::ReturnOutsideFunction => "E0420",
             Self::DuplicateMethod => "E0421",
+            Self::DuplicateConst => "E0422",
 
             Self::ModuleNotFound => "E0500",
             Self::ImportNotFound => "E0501",
@@ -299,6 +303,7 @@ impl ErrorCode {
             "E0023" => Some(Self::ExpectedExprAfterOp),
             "E0024" => Some(Self::InvalidMatchSyntax),
             "E0025" => Some(Self::InvalidForSyntax),
+            "E0026" => Some(Self::InvalidConstExpr),
 
             "E0100" => Some(Self::TypeMismatch),
             "E0101" => Some(Self::UnknownType),
@@ -354,6 +359,7 @@ impl ErrorCode {
             "E0419" => Some(Self::ContinueOutsideLoop),
             "E0420" => Some(Self::ReturnOutsideFunction),
             "E0421" => Some(Self::DuplicateMethod),
+            "E0422" => Some(Self::DuplicateConst),
 
             "E0500" => Some(Self::ModuleNotFound),
             "E0501" => Some(Self::ImportNotFound),
@@ -423,6 +429,7 @@ impl ErrorCode {
             Self::ExpectedExprAfterOp => "EXPECTED EXPRESSION",
             Self::InvalidMatchSyntax => "INVALID MATCH",
             Self::InvalidForSyntax => "INVALID FOR",
+            Self::InvalidConstExpr => "INVALID CONST EXPR",
 
             Self::TypeMismatch => "TYPE MISMATCH",
             Self::UnknownType => "UNKNOWN TYPE",
@@ -460,6 +467,7 @@ impl ErrorCode {
             Self::DuplicateField => "DUPLICATE FIELD",
             Self::DuplicateVariant => "DUPLICATE VARIANT",
             Self::DuplicateMethod => "DUPLICATE METHOD",
+            Self::DuplicateConst => "DUPLICATE CONST",
             Self::InvalidSignature => "INVALID SIGNATURE",
             Self::MissingReturn => "MISSING RETURN",
             Self::UnreachableCode => "UNREACHABLE CODE",

crates/doo_driver/src/compile.rs

@@ -329,19 +329,29 @@ pub fn compile_project(opts: CompileOptions) -> Result<CompileResult, String> {
                 doo_frontend::ast::Item::Enum(e) => doo_debug!("DEBUG", "  Enum: {}", e.name),
                 doo_frontend::ast::Item::Import(i) => doo_debug!("DEBUG", "  Import: {:?}", i.path),
                 doo_frontend::ast::Item::Statement(_) => doo_debug!("DEBUG", "  Statement"),
-                doo_frontend::ast::Item::Policy(p) => doo_debug!("DEBUG", "  Policy for {}", p.for_struct),
-                doo_frontend::ast::Item::Interface(i) => doo_debug!("DEBUG", "  Interface: {}", i.name),
+                doo_frontend::ast::Item::Const(c) => doo_debug!("DEBUG", "  Const: {}", c.name),
+                doo_frontend::ast::Item::Policy(p) => {
+                    doo_debug!("DEBUG", "  Policy for {}", p.for_struct)
+                }
+                doo_frontend::ast::Item::Interface(i) => {
+                    doo_debug!("DEBUG", "  Interface: {}", i.name)
+                }
             }
         }
         doo_debug!("DEBUG", "HIR items: {}", hir.items.len());
         for item in &hir.items {
             match item {
+                doo_hir::HirItem::Const(c) => doo_debug!("DEBUG", "  HIR Const: {}", c.name),
                 doo_hir::HirItem::Function(f) => doo_debug!("DEBUG", "  HIR Function: {}", f.name),
                 doo_hir::HirItem::Struct(s) => doo_debug!("DEBUG", "  HIR Struct: {}", s.name),
                 doo_hir::HirItem::Enum(e) => doo_debug!("DEBUG", "  HIR Enum: {}", e.name),
                 doo_hir::HirItem::Import(_) => doo_debug!("DEBUG", "  HIR Import"),
-                doo_hir::HirItem::Policy(p) => doo_debug!("DEBUG", "  HIR Policy for {}", p.for_struct),
-                doo_hir::HirItem::Interface(i) => doo_debug!("DEBUG", "  HIR Interface: {}", i.name),
+                doo_hir::HirItem::Policy(p) => {
+                    doo_debug!("DEBUG", "  HIR Policy for {}", p.for_struct)
+                }
+                doo_hir::HirItem::Interface(i) => {
+                    doo_debug!("DEBUG", "  HIR Interface: {}", i.name)
+                }
             }
         }
     }

crates/doo_driver/src/loader.rs

@@ -693,6 +693,22 @@ pub fn resolve_imports(
                         result.items.push(item.clone());
                     }
                 }
+                Item::Const(c) => {
+                    let is_public = c
+                        .name
+                        .chars()
+                        .next()
+                        .map(|ch| ch.is_uppercase())
+                        .unwrap_or(false);
+                    let is_wanted = import_all || requested.contains_key(&c.name);
+                    if is_public && is_wanted && !imported_names.contains(&c.name) {
+                        if debug {
+                            doo_debug!("LOADER", "  Importing const: {}", c.name);
+                        }
+                        imported_names.insert(c.name.clone());
+                        result.items.push(item.clone());
+                    }
+                }
                 Item::Import(_) | Item::Statement(_) | Item::Policy(_) | Item::Interface(_) => {
                     // Don't re-export
                 }
@@ -1104,6 +1120,21 @@ pub fn resolve_imports(
                         result.items.push(item.clone());
                     }
                 }
+                Item::Const(c) => {
+                    let is_public = c
+                        .name
+                        .chars()
+                        .next()
+                        .map(|ch| ch.is_uppercase())
+                        .unwrap_or(false);
+                    if is_public && !imported_names.contains(&c.name) {
+                        if debug {
+                            doo_debug!("LOADER", "  Importing local const: {}", c.name);
+                        }
+                        imported_names.insert(c.name.clone());
+                        result.items.push(item.clone());
+                    }
+                }
                 Item::Import(_) | Item::Statement(_) | Item::Policy(_) | Item::Interface(_) => {
                     // Don't re-export
                 }
@@ -1258,7 +1289,24 @@ pub fn resolve_imports(
                             result.items.push(item.clone());
                         }
                     }
-                    Item::Import(_) | Item::Statement(_) | Item::Policy(_) | Item::Interface(_) => {}
+                    Item::Const(c) => {
+                        let is_public = c
+                            .name
+                            .chars()
+                            .next()
+                            .map(|ch| ch.is_uppercase())
+                            .unwrap_or(false);
+                        let is_wanted = import_all || requested.contains_key(&c.name);
+                        if is_public && is_wanted && !imported_names.contains(&c.name) {
+                            if debug {
+                                doo_debug!("LOADER", "  Importing nested-std const: {}", c.name);
+                            }
+                            imported_names.insert(c.name.clone());
+                            result.items.push(item.clone());
+                        }
+                    }
+                    Item::Import(_) | Item::Statement(_) | Item::Policy(_) | Item::Interface(_) => {
+                    }
                 }
             }
         }

crates/doo_frontend/src/ast/decl.rs

@@ -1,10 +1,35 @@
 //! Declaration AST nodes.
 //!
-//! Top-level declarations: functions, structs, enums, imports.
+//! Top-level declarations: functions, structs, enums, imports, consts.
 
-use super::{Stmt, TypeExpr};
+use super::{Expr, Stmt, TypeExpr};
 use doo_core::Span;
 
+// ============================================================================
+// Const Declaration
+// ============================================================================
+
+/// A compile-time constant declaration: `const Name = expr`
+///
+/// - PascalCase name → public const (accessible via import)
+/// - camelCase name  → private const (module-internal)
+/// - Value must be a compile-time literal expression (no function calls, no structs)
+/// - Can hold: primitives (Int, Float, Bool, Str), arrays of primitives, maps of primitives
+#[derive(Debug, Clone)]
+pub struct ConstDecl {
+    pub name: String,
+    pub is_public: bool,
+    pub value: Expr,
+    pub span: Span,
+}
+
+impl ConstDecl {
+    pub fn new(name: String, value: Expr, span: Span) -> Self {
+        let is_public = name.chars().next().map(|c| c.is_uppercase()).unwrap_or(false);
+        Self { name, is_public, value, span }
+    }
+}
+
 // ============================================================================
 // Generic Type Parameters
 // ============================================================================

crates/doo_frontend/src/ast/mod.rs

@@ -35,6 +35,8 @@ impl Program {
 /// Top-level items in a program.
 #[derive(Debug, Clone)]
 pub enum Item {
+    /// Compile-time constant declaration
+    Const(ConstDecl),
     /// Function declaration
     Function(FunctionDecl),
     /// Struct declaration
@@ -54,6 +56,7 @@ pub enum Item {
 impl Item {
     pub fn span(&self) -> Span {
         match self {
+            Self::Const(c) => c.span,
             Self::Function(f) => f.span,
             Self::Struct(s) => s.span,
             Self::Enum(e) => e.span,