refactor: overhaul CLI architecture and enhance backend type handling (#279)

This commit introduces a structured CLI command system, modularizes flag
handling, and improves the LLVM backend's ability to handle implicit
pointer casting and array-literal addressing.

Changes:
- **CLI Overhaul**:
  - Replaced the imperative argument loop in `main.rs` with a structured
    dispatch system in `src/cli.rs`.
  - Introduced `Command` and `Global` enums to manage subcommands (`run`,
    `build`, `img`, `install`, `update`) and global options.
  - Refactored `src/errors.rs` to use a unified `CliError::Usage` variant,
    simplifying error reporting.
  - Moved flag definitions to `src/flags.rs`, adding support for link
    libraries (`--link`) and search paths (`-L`).
  - Updated `src/lib.rs` to export a cleaner API.
- **LLVM Backend Enhancements**:
  - **Address-of Operator**: Heavily refactored `gen_addressof` in
    `pointers.rs` to support taking the address of `ArrayLiteral`
    expressions. It now generates an alloca, stores elements, and returns
    the pointer (with bitcasting if necessary).
  - **Implicit Casting**: Updated variable resolution and address
    generation to perform automatic `bit_cast` when the actual pointer
    type differs from the `expected_type`.
  - **Type Inference**: Passed `expected_type` down to variable
    generation to allow context-aware LLVM IR emission.
- **Linker & Runner Updates**:
  - Updated `runner.rs` to propagate `LinkFlags` (libraries and paths)
    to the object linking phase.
  - Renamed standard library management functions in `src/std.rs`
    (e.g., `std_install`) for better naming consistency.
- **Cleanup**:
  - Removed unused imports in `control.rs`.
  - Simplified assembly clobber normalization logic.

These changes significantly improve the maintainability of the compiler's
entry point and provide a more robust type-coercion system in the backend.

Author: LunaStev

llvm_temporary/src/llvm_temporary/expression/rvalue/dispatch.rs

@@ -10,7 +10,7 @@ pub(crate) fn gen_expr<'ctx, 'a>(
 ) -> BasicValueEnum<'ctx> {
     match expr {
         Expression::Literal(lit) => literals::gen(env, lit, expected_type),
-        Expression::Variable(name) => variables::gen(env, name),
+        Expression::Variable(name) => variables::gen(env, name, expected_type),
 
         Expression::Deref(inner) => pointers::gen_deref(env, inner),
         Expression::AddressOf(inner) => pointers::gen_addressof(env, inner, expected_type),

llvm_temporary/src/llvm_temporary/expression/rvalue/pointers.rs

@@ -1,5 +1,5 @@
 use super::ExprGenEnv;
-use inkwell::types::{BasicType, BasicTypeEnum};
+use inkwell::types::{AnyTypeEnum, BasicType, BasicTypeEnum};
 use inkwell::values::{BasicValue, BasicValueEnum};
 use parser::ast::Expression;
 use crate::llvm_temporary::llvm_codegen::generate_address_ir;
@@ -73,53 +73,90 @@ pub(crate) fn gen_addressof<'ctx, 'a>(
     inner_expr: &Expression,
     expected_type: Option<BasicTypeEnum<'ctx>>,
 ) -> BasicValueEnum<'ctx> {
-    if let Some(BasicTypeEnum::PointerType(ptr_ty)) = expected_type {
-        match inner_expr {
-            Expression::ArrayLiteral(elements) => unsafe {
-                let array_type = ptr_ty.get_element_type().into_array_type();
-                let elem_type = array_type.get_element_type();
-
-                let array_type = elem_type.array_type(elements.len() as u32);
-                let tmp_alloca = env.builder.build_alloca(array_type, "tmp_array").unwrap();
-
-                for (i, expr) in elements.iter().enumerate() {
-                    let val = env.gen(expr, Some(elem_type));
-
-                    let gep = env
-                        .builder
-                        .build_in_bounds_gep(
-                            tmp_alloca,
-                            &[
-                                env.context.i32_type().const_zero(),
-                                env.context.i32_type().const_int(i as u64, false),
-                            ],
-                            &format!("array_idx_{}", i),
-                        )
-                        .unwrap();
-
-                    env.builder.build_store(gep, val).unwrap();
-                }
-
-                let alloca = env
-                    .builder
-                    .build_alloca(tmp_alloca.get_type(), "tmp_array_ptr")
-                    .unwrap();
-
-                env.builder.build_store(alloca, tmp_alloca).unwrap();
-                alloca.as_basic_value_enum()
-            },
-
-            Expression::Variable(var_name) => {
-                let ptr = env
-                    .variables
-                    .get(var_name)
-                    .unwrap_or_else(|| panic!("Variable {} not found", var_name));
-                ptr.ptr.as_basic_value_enum()
+    if let Expression::ArrayLiteral(elements) = inner_expr {
+        let ptr_ty = match expected_type {
+            Some(BasicTypeEnum::PointerType(p)) => p,
+            _ => panic!("&[ ... ] needs an expected pointer type (e.g. ptr<i32>)"),
+        };
+
+        let elem_any = ptr_ty.get_element_type();
+        let elem_basic: BasicTypeEnum<'ctx> = match elem_any {
+            AnyTypeEnum::IntType(t) => t.into(),
+            AnyTypeEnum::FloatType(t) => t.into(),
+            AnyTypeEnum::PointerType(t) => t.into(),
+            AnyTypeEnum::StructType(t) => t.into(),
+            AnyTypeEnum::ArrayType(t) => t.into(),
+            AnyTypeEnum::VectorType(t) => t.into(),
+            other => panic!("&[ ... ] unsupported element type: {:?}", other),
+        };
+
+        let array_ty = elem_basic.array_type(elements.len() as u32);
+        let arr_alloca = env.builder.build_alloca(array_ty, "tmp_array").unwrap();
+
+        for (i, expr) in elements.iter().enumerate() {
+            let val = env.gen(expr, Some(elem_basic));
+
+            let gep = unsafe {
+                env.builder
+                    .build_in_bounds_gep(
+                        arr_alloca,
+                        &[
+                            env.context.i32_type().const_zero(),
+                            env.context.i32_type().const_int(i as u64, false),
+                        ],
+                        &format!("array_idx_{}", i),
+                    )
+                    .unwrap()
+            };
+
+            env.builder.build_store(gep, val).unwrap();
+        }
+
+        if elem_basic == ptr_ty.get_element_type().try_into().unwrap() {
+            let first = unsafe {
+                env.builder
+                    .build_in_bounds_gep(
+                        arr_alloca,
+                        &[
+                            env.context.i32_type().const_zero(),
+                            env.context.i32_type().const_zero(),
+                        ],
+                        "array_first_ptr",
+                    )
+                    .unwrap()
+            };
+
+            if first.get_type() != ptr_ty {
+                return env.builder
+                    .build_bit_cast(first, ptr_ty, "addrof_array_cast")
+                    .unwrap()
+                    .as_basic_value_enum();
             }
 
-            _ => panic!("& operator must be used on variable name or array literal"),
+            return first.as_basic_value_enum();
         }
-    } else {
-        panic!("Expected pointer type for AddressOf");
+
+        return arr_alloca.as_basic_value_enum();
     }
+
+    let addr = generate_address_ir(
+        env.context,
+        env.builder,
+        inner_expr,
+        env.variables,
+        env.module,
+        env.struct_types,
+        env.struct_field_indices,
+    );
+
+    if let Some(BasicTypeEnum::PointerType(ptr_ty)) = expected_type {
+        if addr.get_type() != ptr_ty {
+            return env.builder
+                .build_bit_cast(addr, ptr_ty, "addrof_cast")
+                .unwrap()
+                .as_basic_value_enum();
+        }
+    }
+
+    addr.as_basic_value_enum()
 }

llvm_temporary/src/llvm_temporary/expression/rvalue/variables.rs

@@ -1,9 +1,13 @@
 use inkwell::AddressSpace;
 use super::ExprGenEnv;
-use inkwell::types::AnyTypeEnum;
+use inkwell::types::{AnyTypeEnum, BasicTypeEnum};
 use inkwell::values::{BasicValue, BasicValueEnum};
 
-pub(crate) fn gen<'ctx, 'a>(env: &mut ExprGenEnv<'ctx, 'a>, var_name: &str) -> BasicValueEnum<'ctx> {
+pub(crate) fn gen<'ctx, 'a>(
+    env: &mut ExprGenEnv<'ctx, 'a>,
+    var_name: &str,
+    expected_type: Option<BasicTypeEnum<'ctx>>,
+) -> BasicValueEnum<'ctx> {
     if var_name == "true" {
         return env.context.bool_type().const_int(1, false).as_basic_value_enum();
     } else if var_name == "false" {
@@ -21,13 +25,28 @@ pub(crate) fn gen<'ctx, 'a>(env: &mut ExprGenEnv<'ctx, 'a>, var_name: &str) -> B
     }
 
     if let Some(var_info) = env.variables.get(var_name) {
-        let var_type = var_info.ptr.get_type().get_element_type();
+        let ptr = var_info.ptr;
 
-        match var_type {
-            AnyTypeEnum::ArrayType(_) => var_info.ptr.as_basic_value_enum(),
+        if let Some(et) = expected_type {
+            if et.is_pointer_type() {
+                let expected_ptr = et.into_pointer_type();
+                if ptr.get_type() != expected_ptr {
+                    return env
+                        .builder
+                        .build_bit_cast(ptr, expected_ptr, &format!("{}_as_ptr", var_name))
+                        .unwrap()
+                        .as_basic_value_enum();
+                }
+                return ptr.as_basic_value_enum();
+            }
+        }
+
+        let elem_ty = ptr.get_type().get_element_type();
+        match elem_ty {
+            AnyTypeEnum::ArrayType(_) => ptr.as_basic_value_enum(),
             _ => env
                 .builder
-                .build_load(var_info.ptr, var_name)
+                .build_load(ptr, &format!("load_{}", var_name))
                 .unwrap()
                 .as_basic_value_enum(),
         }
@@ -36,4 +55,4 @@ pub(crate) fn gen<'ctx, 'a>(env: &mut ExprGenEnv<'ctx, 'a>, var_name: &str) -> B
     } else {
         panic!("variable '{}' not found in current scope", var_name);
     }
-}
+}

llvm_temporary/src/llvm_temporary/llvm_codegen/plan.rs

@@ -233,7 +233,6 @@ fn normalize_clobber_item(s: &str) -> String {
         panic!("Invalid clobber token: '{}'", inner);
     }
 
-    // "{...}" 형태
     if let Some(inner) = t.strip_prefix('{').and_then(|x| x.strip_suffix('}')) {
         let n = normalize_token(inner);
 

llvm_temporary/src/llvm_temporary/statement/control.rs

@@ -2,8 +2,8 @@ use crate::llvm_temporary::llvm_codegen::VariableInfo;
 use crate::llvm_temporary::expression::rvalue::generate_expression_ir;
 use inkwell::basic_block::BasicBlock;
 use inkwell::module::Module;
-use inkwell::types::{AnyTypeEnum, BasicTypeEnum, StructType};
-use inkwell::values::{BasicValue, BasicValueEnum, FunctionValue};
+use inkwell::types::{StructType};
+use inkwell::values::{BasicValueEnum, FunctionValue};
 use inkwell::{FloatPredicate, IntPredicate};
 use parser::ast::{ASTNode, Expression};
 use std::collections::HashMap;