Updated support for C function pointers so raylib header works again

Author: IsaacShelton

Diff for: src/asg/datatype/mod.rs

@@ -45,7 +45,12 @@ impl Type {
             TypeKind::AnonymousUnion() => todo!("strip_constraints for anonymous union"),
             TypeKind::AnonymousEnum(_) => (),
             TypeKind::FixedArray(fixed_array) => fixed_array.inner.strip_constraints(),
-            TypeKind::FuncPtr(_) => todo!("strip_constraints for function pointer"),
+            TypeKind::FuncPtr(func) => {
+                for param in func.params.required.iter_mut() {
+                    param.ty.strip_constraints();
+                }
+                func.return_type.strip_constraints();
+            }
             TypeKind::Enum(_, _) => (),
             TypeKind::Structure(_, _, parameters) => {
                 for parameter in parameters {

Diff for: src/resolve/polymorph/resolver.rs

@@ -69,7 +69,32 @@ impl<'a> PolyRecipeResolver<'a> {
                 }))
                 .at(ty.source)
             }
-            asg::TypeKind::FuncPtr(_) => todo!(),
+            asg::TypeKind::FuncPtr(func) => {
+                let required = func
+                    .params
+                    .required
+                    .iter()
+                    .map(|param| {
+                        self.resolve_type(&param.ty).and_then(|ty| {
+                            Ok(asg::Param {
+                                name: param.name.clone(),
+                                ty,
+                            })
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                let return_type = self.resolve_type(&func.return_type)?;
+
+                asg::TypeKind::FuncPtr(asg::FuncPtr {
+                    params: asg::Params {
+                        required,
+                        is_cstyle_vararg: func.params.is_cstyle_vararg,
+                    },
+                    return_type: Box::new(return_type),
+                })
+                .at(ty.source)
+            }
             asg::TypeKind::Enum(_, _) => ty.clone(),
             asg::TypeKind::Structure(human_name, struct_ref, poly_args) => {
                 let args = poly_args