Working param and return type fn type

crates/codegen/src/class_decl.rs

@@ -317,13 +317,26 @@ pub fn gen_method_point(method: &FunctionDecl, ctx: &mut Context, cg: &mut RustC
 
     param_types.remove(0);
 
-    // param_types.insert(0, );
+    param_types.insert(
+        0,
+        TypeExpr::UnsafePtr {
+            mutable: true,
+            ty: Box::new(TypeExpr::Path(
+                Path(vec![
+                    Identifier(String::from("std")),
+                    Identifier(String::from("ffi")),
+                    Identifier(String::from("c_void")),
+                ]),
+                None,
+            )),
+        },
+    );
 
-    cg.add(&TypeExpr::StaticFn(param_types).get_rust());
+    cg.add(&TypeExpr::StaticFn(param_types, method.return_type.clone().map(Box::new)).get_rust());
 
     cg.addln(" = std::mem::transmute(func_ptr);");
 
-    cg.add_indentedln("func(self._m_oop.1);");
+    cg.add_indentedln("func(self._m_oop.1)");
 
     cg.indent -= 1;
     cg.add_indentedln("}");

crates/codegen/src/lib.rs

@@ -192,14 +192,33 @@ impl GetRust for TypeExpr {
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
-            Self::StaticFn(types) => format!(
+            Self::StaticFn(types, return_type) => {
+                if let Some(return_type) = return_type {
+                    format!(
+                        "fn({}) -> {}",
+                        types
+                            .into_iter()
+                            .map(|t| t.get_rust())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                        return_type.get_rust()
+                    )
+                } else {
+                    format!(
                         "fn({})",
                         types
                             .into_iter()
                             .map(|t| t.get_rust())
                             .collect::<Vec<_>>()
-                    .join(", ")
+                            .join(", "),
-            ),
+                    )
+                }
+            }
+
+            Self::UnsafePtr { mutable, ty } => {
+                let mutable = if *mutable { "mut " } else { "const " };
+                format!("*{mutable}{}", ty.get_rust())
+            }
 
             Self::Ref {
                 lifetime,

crates/parser/src/ast/mod.rs

@@ -24,9 +24,13 @@ pub enum TypeExpr {
         mutable: bool,
         ty: Box<TypeExpr>,
     },
+    UnsafePtr {
+        mutable: bool,
+        ty: Box<TypeExpr>,
+    },
     Dyn(Box<TypeExpr>),
     Path(Path, Option<Generics>),
-    StaticFn(Vec<TypeExpr>),
+    StaticFn(Vec<TypeExpr>, Option<Box<TypeExpr>>),
     Tuple(Vec<TypeExpr>),
     Lifetime(Identifier),
 }