Merge pull request #55 from Tcode-Motion/fix-compilation-and-clippy-4585464244175969887

🧹 [Code Health] Fix workspace compilation errors and clippy warnings

Author: Tcode-Motion

Cargo.lock

@@ -37,10 +37,10 @@ anyhow = { workspace = true }
 rustyline = { workspace = true }
 toml = { workspace = true }
 indexmap = { workspace = true }
-bincode = "3.0"
+bincode = "1.3.3"
 dirs = "6.0"
 num_cpus = "1.15"
-ureq = { version = "3.4.0" }
+ureq = { version = "2.9" }
 
 [build-dependencies]
 winres = "0.1.12"

cli/Cargo.toml

@@ -10,7 +10,7 @@ techscript_syntax = { path = "../syntax" }
 techscript_ast = { path = "../ast" }
 techscript_ir = { path = "../ir" }
 serde = { workspace = true }
-bincode = "3.0"
+bincode = "1.3.3"
 
 [dev-dependencies]
 techscript_errors = { path = "../errors" }
@@ -19,4 +19,4 @@ techscript_parser = { path = "../parser" }
 techscript_semantic = { path = "../semantic" }
 techscript_optimizer = { path = "../optimizer" }
 serde = { workspace = true }
-bincode = "3.0"
+bincode = "1.3.3"

compiler/bytecode/Cargo.toml

@@ -9,7 +9,7 @@ techscript_common = { path = "../common" }
 techscript_ir = { path = "../ir" }
 techscript_ast = { path = "../ast" }
 techscript_syntax = { path = "../syntax" }
-llvm-sys = { version = "221", optional = true }
+llvm-sys = { version = "180", optional = true }
 serde = { workspace = true }
 anyhow = { workspace = true }
 thiserror = { workspace = true }

compiler/llvm_backend/Cargo.toml

@@ -33,11 +33,14 @@ impl<'a> CodegenEngine<'a> {
         }
     }
 
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn compile_module(&mut self, ir_module: &Module) -> Result<(), String> {
         self.global_names.clear();
 
         // 1. Declare globals
-        for &(ref global_id, ref name, ref ty) in &ir_module.globals {
+        for (global_id, name, ty) in &ir_module.globals {
             let llvm_ty = to_llvm_type(self.ctx.context, ty);
             let global_var = LLVMAddGlobal(
                 self.ctx.module,
@@ -124,8 +127,6 @@ impl<'a> CodegenEngine<'a> {
                         let dest_block = self.ctx.get_block(*dest).unwrap();
                         LLVMBuildBr(self.ctx.builder, dest_block);
                     }
-<
-                    }
                     TerminatorKind::ConditionalJump {
                         cond,
                         then_block,
@@ -199,6 +200,25 @@ impl<'a> CodegenEngine<'a> {
                     TerminatorKind::Unreachable => {
                         LLVMBuildUnreachable(self.ctx.builder);
                     }
+                    TerminatorKind::Throw(val) => {
+                        let thrown_val = self.codegen_val(val)?;
+                        let boxed_val = self.box_val(thrown_val)?;
+                        let i8_ptr_ty = LLVMPointerType(LLVMInt8TypeInContext(self.ctx.context), 0);
+                        let fn_throw = self.get_or_declare_runtime_fn(
+                            "ts_throw",
+                            LLVMVoidTypeInContext(self.ctx.context),
+                            &[i8_ptr_ty],
+                        );
+                        LLVMBuildCall2(
+                            self.ctx.builder,
+                            LLVMTypeOf(fn_throw),
+                            fn_throw,
+                            [boxed_val].as_mut_ptr(),
+                            1,
+                            c"".as_ptr(),
+                        );
+                        LLVMBuildUnreachable(self.ctx.builder);
+                    }
                 }
             }
         }
@@ -1056,7 +1076,10 @@ impl<'a> CodegenEngine<'a> {
                     CString::new("cast").unwrap().as_ptr(),
                 )
             }
-            Op::Try { catch_block, catch_var } => {
+            Op::Try {
+                catch_block,
+                catch_var,
+            } => {
                 let i8_ptr_ty = LLVMPointerType(LLVMInt8TypeInContext(context), 0);
                 let fn_push = self.get_or_declare_runtime_fn("ts_try_push", i8_ptr_ty, &[]);
                 let buf_ptr = LLVMBuildCall2(
@@ -1120,7 +1143,11 @@ impl<'a> CodegenEngine<'a> {
                 LLVMPositionBuilderAtEnd(self.ctx.builder, dispatch_block);
 
                 // Clean up the jmp_buf since we arrived here via longjmp and ts_try_pop wasn't called
-                let fn_free_buf = self.get_or_declare_runtime_fn("ts_try_free", LLVMVoidTypeInContext(context), &[i8_ptr_ty]);
+                let fn_free_buf = self.get_or_declare_runtime_fn(
+                    "ts_try_free",
+                    LLVMVoidTypeInContext(context),
+                    &[i8_ptr_ty],
+                );
                 LLVMBuildCall2(
                     self.ctx.builder,
                     LLVMTypeOf(fn_free_buf),
@@ -1151,7 +1178,11 @@ impl<'a> CodegenEngine<'a> {
                 return Ok(());
             }
             Op::EndTry => {
-                let fn_pop = self.get_or_declare_runtime_fn("ts_try_pop", LLVMVoidTypeInContext(context), &[]);
+                let fn_pop = self.get_or_declare_runtime_fn(
+                    "ts_try_pop",
+                    LLVMVoidTypeInContext(context),
+                    &[],
+                );
                 LLVMBuildCall2(
                     self.ctx.builder,
                     LLVMTypeOf(fn_pop),

compiler/llvm_backend/src/codegen.rs

@@ -21,6 +21,9 @@ pub struct CodegenContext {
 }
 
 impl CodegenContext {
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn new(name: &str) -> Self {
         let context = LLVMContextCreate();
         let module =

compiler/llvm_backend/src/context.rs

@@ -4,7 +4,6 @@
 
 #![cfg(feature = "llvm")]
 
-use llvm_sys::core::*;
 use llvm_sys::orc2::lljit::*;
 use llvm_sys::orc2::*;
 use std::collections::HashMap;
@@ -23,6 +22,9 @@ pub struct LLVMJitEngine {
 
 impl LLVMJitEngine {
     /// Creates a new LLVMJitEngine instance.
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn new() -> Result<Self, String> {
         let mut jit = ptr::null_mut();
         let builder = LLVMOrcCreateLLJITBuilder();
@@ -41,10 +43,13 @@ impl LLVMJitEngine {
     }
 
     /// Compiles a TechScript IR Module to JIT memory.
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn compile(
         &mut self,
         ir_module: &techscript_ir::Module,
-        options: &LLVMBackendOptions,
+        _options: &LLVMBackendOptions,
     ) -> Result<(), String> {
         // 1. Build LLVM IR Module
         let mut ctx = CodegenContext::new(&ir_module.name);
@@ -79,6 +84,9 @@ impl LLVMJitEngine {
     }
 
     /// Looks up a function symbol by name.
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn lookup(&mut self, name: &str) -> Result<u64, String> {
         if let Some(&addr) = self.cache.get(name) {
             return Ok(addr);
@@ -96,13 +104,19 @@ impl LLVMJitEngine {
     }
 
     /// Executes the JIT-compiled main function and returns its result (if integer).
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn execute(&mut self, func_name: &str) -> Result<i64, String> {
         let addr = self.lookup(func_name)?;
         let func: extern "C" fn() -> i64 = std::mem::transmute(addr);
         Ok(func())
     }
 
     /// Clears the function cache and reloads the engine (for hot reload support).
+    /// # Safety
+    ///
+    /// Caller must ensure LLVM context is valid.
     pub unsafe fn hot_reload(&mut self) {
         self.cache.clear();
     }

compiler/llvm_backend/src/jit.rs

@@ -104,7 +104,7 @@ impl LLVMBackend {
             let mut engine = CodegenEngine::new(&mut ctx);
             engine
                 .compile_module(ir_module)
-                .map_err(|e| LLVMCodegenError::CompilationError(e))?;
+                .map_err(LLVMCodegenError::CompilationError)?;
 
             let out_str = CString::new(out_path.to_string_lossy().to_string()).unwrap();
             let mut err_msg = std::ptr::null_mut();
@@ -147,7 +147,7 @@ impl LLVMBackend {
 
         engine
             .compile_module(ir_module)
-            .map_err(|e| LLVMCodegenError::CompilationError(e))?;
+            .map_err(LLVMCodegenError::CompilationError)?;
 
         // 3. Resolve Target Triple & Host CPU Features
         let triple_cstr = CString::new(options.target_triple.as_str()).unwrap();

compiler/llvm_backend/src/lib.rs

@@ -9,6 +9,9 @@ use llvm_sys::prelude::*;
 use techscript_ir::types::IRType;
 
 /// Maps a TechScript IRType to its corresponding LLVMTypeRef.
+/// # Safety
+///
+/// Caller must ensure LLVM context is valid.
 pub unsafe fn to_llvm_type(context: LLVMContextRef, ty: &IRType) -> LLVMTypeRef {
     match ty {
         IRType::Void => LLVMVoidTypeInContext(context),

compiler/llvm_backend/src/type_map.rs

@@ -1037,8 +1037,8 @@ extern "C" {
 }
 
 thread_local! {
-    static TRY_STACK: RefCell<Vec<*mut JmpBuf>> = RefCell::new(Vec::new());
-    static PENDING_EXCEPTION: RefCell<*mut TsValue> = RefCell::new(std::ptr::null_mut());
+    static TRY_STACK: RefCell<Vec<*mut JmpBuf>> = const { RefCell::new(Vec::new()) };
+    static PENDING_EXCEPTION: RefCell<*mut TsValue> = const { RefCell::new(std::ptr::null_mut()) };
 }
 
 #[no_mangle]