fix: missing closure assign tp check & fn auto cast

Author: Chronostasys

src/ast/ctx.rs

@@ -23,6 +23,7 @@ use super::traits::CustomType;
 
 use crate::ast::builder::BuilderEnum;
 use crate::ast::builder::IRBuilder;
+use crate::format_label;
 use crate::lsp::semantic_tokens::type_index;
 
 use crate::mismatch_err;
@@ -221,7 +222,24 @@ impl<'a, 'ctx> Ctx<'a> {
         ori_value: usize,
         builder: &'b BuilderEnum<'a, 'ctx>,
     ) -> Result<usize, PLDiag> {
-        if let PLType::Closure(_) = &*target_pltype.borrow() {
+        if let (PLType::Closure(c), PLType::Fn(f)) =
+            (&*target_pltype.borrow(), &*ori_pltype.borrow())
+        {
+            if f.to_closure_ty(self, builder) != *c {
+                return Err(ori_range
+                    .new_err(ErrorCode::FUNCTION_TYPE_NOT_MATCH)
+                    .add_label(
+                        target_range,
+                        self.get_file(),
+                        format_label!("expected type `{}`", c.get_name()),
+                    )
+                    .add_label(
+                        ori_range,
+                        self.get_file(),
+                        format_label!("found type `{}`", f.to_closure_ty(self, builder).get_name()),
+                    )
+                    .add_to_ctx(self));
+            }
             if ori_value == usize::MAX {
                 return Err(ori_range
                     .new_err(ErrorCode::CANNOT_ASSIGN_INCOMPLETE_GENERICS)

src/ast/diag.rs

@@ -122,6 +122,7 @@ define_error!(
     METHOD_NOT_FOUND = "method not found",
     DERIVE_TRAIT_NOT_IMPL = "derive trait not impl",
     CANNOT_ASSIGN_INCOMPLETE_GENERICS = "cannot assign incomplete generic function to variable",
+    FUNCTION_TYPE_NOT_MATCH = "function type not match",
 );
 macro_rules! define_warn {
     ($(

src/ast/node/statement.rs

@@ -64,12 +64,28 @@ impl Node for DefNode {
                 return Err(ctx.add_diag(self.range.new_err(ErrorCode::UNDEFINED_TYPE)));
             }
             let re = re.unwrap();
-            let tp = re.get_ty();
+            let mut tp = re.get_ty();
+            let v = if let PLType::Fn(f) = &*tp.clone().borrow() {
+                let oritp = tp;
+                let c = Arc::new(RefCell::new(PLType::Closure(f.to_closure_ty(ctx, builder))));
+                tp = c.clone();
+                ctx.up_cast(
+                    c,
+                    oritp,
+                    Default::default(),
+                    Default::default(),
+                    re.get_value(),
+                    builder,
+                )
+                .unwrap()
+            } else {
+                re.get_value()
+            };
             if pltype.is_none() {
                 ctx.push_type_hints(self.var.range, tp.clone());
                 pltype = Some(tp);
             }
-            expv = Some(re.get_value());
+            expv = Some(v);
         }
         let pltype = pltype.unwrap();
         let ptr2value = builder.alloc(

src/ast/pltype.rs

@@ -600,6 +600,22 @@ impl TryFrom<PLType> for FNValue {
     }
 }
 impl FNValue {
+    pub fn to_closure_ty<'a, 'ctx, 'b>(
+        &self,
+        ctx: &'b mut Ctx<'a>,
+        builder: &'b BuilderEnum<'a, 'ctx>,
+    ) -> ClosureType {
+        return ClosureType {
+            range: Default::default(),
+            ret_type: self.fntype.ret_pltype.get_type(ctx, builder).unwrap(),
+            arg_types: self
+                .fntype
+                .param_pltypes
+                .iter()
+                .map(|x| x.get_type(ctx, builder).unwrap())
+                .collect(),
+        };
+    }
     pub fn is_modified_by(&self, modifier: TokenType) -> bool {
         if let Some((t, _)) = self.fntype.modifier {
             t == modifier