Make all callbacks optional in libgit2-sys

alexcrichton · alexcrichton · commit d70b64599a08 · 2020-03-13T09:13:44.000-07:00
Appease the nightly compiler's checks for undefinededness and reflect
how this is actually what the typedef is in C, a nullable function
pointer.
diff --git a/libgit2-sys/lib.rs b/libgit2-sys/lib.rs
diff --git a/src/blob.rs b/src/blob.rs
@@ -124,19 +124,27 @@ impl<'repo> Drop for BlobWriter<'repo> {
     fn drop(&mut self) {
         // We need cleanup in case the stream has not been committed
         if self.need_cleanup {
-            unsafe { ((*self.raw).free)(self.raw) }
+            unsafe {
+                if let Some(f) = (*self.raw).free {
+                    f(self.raw)
+                }
+            }
         }
     }
 }
 
 impl<'repo> io::Write for BlobWriter<'repo> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         unsafe {
-            let res = ((*self.raw).write)(self.raw, buf.as_ptr() as *const _, buf.len());
-            if res < 0 {
-                Err(io::Error::new(io::ErrorKind::Other, "Write error"))
+            if let Some(f) = (*self.raw).write {
+                let res = f(self.raw, buf.as_ptr() as *const _, buf.len());
+                if res < 0 {
+                    Err(io::Error::new(io::ErrorKind::Other, "Write error"))
+                } else {
+                    Ok(buf.len())
+                }
             } else {
-                Ok(buf.len())
+                Err(io::Error::new(io::ErrorKind::Other, "no write callback"))
             }
         }
     }
diff --git a/src/build.rs b/src/build.rs
@@ -589,13 +589,11 @@ impl<'cb> CheckoutBuilder<'cb> {
             opts.their_label = c.as_ptr();
         }
         if self.progress.is_some() {
-            let f: raw::git_checkout_progress_cb = progress_cb;
-            opts.progress_cb = Some(f);
+            opts.progress_cb = Some(progress_cb);
             opts.progress_payload = self as *mut _ as *mut _;
         }
         if self.notify.is_some() {
-            let f: raw::git_checkout_notify_cb = notify_cb;
-            opts.notify_cb = Some(f);
+            opts.notify_cb = Some(notify_cb);
             opts.notify_payload = self as *mut _ as *mut _;
             opts.notify_flags = self.notify_flags.bits() as c_uint;
         }
diff --git a/src/cred.rs b/src/cred.rs
@@ -179,7 +179,11 @@ impl Binding for Cred {
 impl Drop for Cred {
     fn drop(&mut self) {
         if !self.raw.is_null() {
-            unsafe { ((*self.raw).free)(self.raw) }
+            unsafe {
+                if let Some(f) = (*self.raw).free {
+                    f(self.raw)
+                }
+            }
         }
     }
 }
diff --git a/src/diff.rs b/src/diff.rs
@@ -164,13 +164,9 @@ impl<'repo> Diff<'repo> {
     {
         let mut cb: &mut PrintCb<'_> = &mut cb;
         let ptr = &mut cb as *mut _;
+        let print: raw::git_diff_line_cb = Some(print_cb);
         unsafe {
-            try_call!(raw::git_diff_print(
-                self.raw,
-                format,
-                print_cb,
-                ptr as *mut _
-            ));
+            try_call!(raw::git_diff_print(self.raw, format, print, ptr as *mut _));
             Ok(())
         }
     }
@@ -194,24 +190,25 @@ impl<'repo> Diff<'repo> {
         };
         let ptr = &mut cbs as *mut _;
         unsafe {
-            let binary_cb_c = if cbs.binary.is_some() {
-                Some(binary_cb_c as raw::git_diff_binary_cb)
+            let binary_cb_c: raw::git_diff_binary_cb = if cbs.binary.is_some() {
+                Some(binary_cb_c)
             } else {
                 None
             };
-            let hunk_cb_c = if cbs.hunk.is_some() {
-                Some(hunk_cb_c as raw::git_diff_hunk_cb)
+            let hunk_cb_c: raw::git_diff_hunk_cb = if cbs.hunk.is_some() {
+                Some(hunk_cb_c)
             } else {
                 None
             };
-            let line_cb_c = if cbs.line.is_some() {
-                Some(line_cb_c as raw::git_diff_line_cb)
+            let line_cb_c: raw::git_diff_line_cb = if cbs.line.is_some() {
+                Some(line_cb_c)
             } else {
                 None
             };
+            let file_cb: raw::git_diff_file_cb = Some(file_cb_c);
             try_call!(raw::git_diff_foreach(
                 self.raw,
-                file_cb_c,
+                file_cb,
                 binary_cb_c,
                 hunk_cb_c,
                 line_cb_c,
diff --git a/src/index.rs b/src/index.rs
@@ -295,7 +295,7 @@ impl Index {
         let ptr = cb.as_mut();
         let callback = ptr
             .as_ref()
-            .map(|_| index_matched_path_cb as raw::git_index_matched_path_cb);
+            .map(|_| index_matched_path_cb as extern "C" fn(_, _, _) -> _);
         unsafe {
             try_call!(raw::git_index_add_all(
                 self.raw,
@@ -473,7 +473,7 @@ impl Index {
         let ptr = cb.as_mut();
         let callback = ptr
             .as_ref()
-            .map(|_| index_matched_path_cb as raw::git_index_matched_path_cb);
+            .map(|_| index_matched_path_cb as extern "C" fn(_, _, _) -> _);
         unsafe {
             try_call!(raw::git_index_remove_all(
                 self.raw,
@@ -511,7 +511,7 @@ impl Index {
         let ptr = cb.as_mut();
         let callback = ptr
             .as_ref()
-            .map(|_| index_matched_path_cb as raw::git_index_matched_path_cb);
+            .map(|_| index_matched_path_cb as extern "C" fn(_, _, _) -> _);
         unsafe {
             try_call!(raw::git_index_update_all(
                 self.raw,
diff --git a/src/odb.rs b/src/odb.rs
@@ -98,9 +98,10 @@ impl<'repo> Odb<'repo> {
             let mut data = ForeachCbData {
                 callback: &mut callback,
             };
+            let cb: raw::git_odb_foreach_cb = Some(foreach_cb);
             try_call!(raw::git_odb_foreach(
                 self.raw(),
-                foreach_cb,
+                cb,
                 &mut data as *mut _ as *mut _
             ));
             Ok(())
@@ -155,7 +156,7 @@ impl<'repo> Odb<'repo> {
     pub fn packwriter(&self) -> Result<OdbPackwriter<'_>, Error> {
         let mut out = ptr::null_mut();
         let progress = MaybeUninit::uninit();
-        let progress_cb = write_pack_progress_cb;
+        let progress_cb: raw::git_indexer_progress_cb = Some(write_pack_progress_cb);
         let progress_payload = Box::new(OdbPackwriterCb { cb: None });
         let progress_payload_ptr = Box::into_raw(progress_payload);
 
diff --git a/src/packbuilder.rs b/src/packbuilder.rs
@@ -89,10 +89,11 @@ impl<'repo> PackBuilder<'repo> {
     {
         let mut cb = &mut cb as &mut ForEachCb<'_>;
         let ptr = &mut cb as *mut _;
+        let foreach: raw::git_packbuilder_foreach_cb = Some(foreach_c);
         unsafe {
             try_call!(raw::git_packbuilder_foreach(
                 self.raw,
-                foreach_c,
+                foreach,
                 ptr as *mut _
             ));
         }
@@ -112,7 +113,7 @@ impl<'repo> PackBuilder<'repo> {
     {
         let mut progress = Box::new(Box::new(progress) as Box<ProgressCb<'_>>);
         let ptr = &mut *progress as *mut _;
-        let progress_c = Some(progress_c as raw::git_packbuilder_progress);
+        let progress_c: raw::git_packbuilder_progress = Some(progress_c);
         unsafe {
             try_call!(raw::git_packbuilder_set_callbacks(
                 self.raw,
diff --git a/src/patch.rs b/src/patch.rs
@@ -206,7 +206,8 @@ impl<'buffers> Patch<'buffers> {
     pub fn print(&mut self, mut line_cb: &mut LineCb<'_>) -> Result<(), Error> {
         let ptr = &mut line_cb as *mut _ as *mut c_void;
         unsafe {
-            try_call!(raw::git_patch_print(self.raw, print_cb, ptr));
+            let cb: raw::git_diff_line_cb = Some(print_cb);
+            try_call!(raw::git_patch_print(self.raw, cb, ptr));
             Ok(())
         }
     }
diff --git a/src/remote_callbacks.rs b/src/remote_callbacks.rs
@@ -174,24 +174,19 @@ impl<'a> Binding for RemoteCallbacks<'a> {
                 0
             );
             if self.progress.is_some() {
-                let f: raw::git_indexer_progress_cb = transfer_progress_cb;
-                callbacks.transfer_progress = Some(f);
+                callbacks.transfer_progress = Some(transfer_progress_cb);
             }
             if self.credentials.is_some() {
-                let f: raw::git_cred_acquire_cb = credentials_cb;
-                callbacks.credentials = Some(f);
+                callbacks.credentials = Some(credentials_cb);
             }
             if self.sideband_progress.is_some() {
-                let f: raw::git_transport_message_cb = sideband_progress_cb;
-                callbacks.sideband_progress = Some(f);
+                callbacks.sideband_progress = Some(sideband_progress_cb);
             }
             if self.certificate_check.is_some() {
-                let f: raw::git_transport_certificate_check_cb = certificate_check_cb;
-                callbacks.certificate_check = Some(f);
+                callbacks.certificate_check = Some(certificate_check_cb);
             }
             if self.push_update_reference.is_some() {
-                let f: extern "C" fn(_, _, _) -> c_int = push_update_reference_cb;
-                callbacks.push_update_reference = Some(f);
+                callbacks.push_update_reference = Some(push_update_reference_cb);
             }
             if self.update_tips.is_some() {
                 let f: extern "C" fn(
diff --git a/src/repo.rs b/src/repo.rs
@@ -778,9 +778,10 @@ impl Repository {
                 repo: self,
                 ret: &mut ret,
             };
+            let cb: raw::git_submodule_cb = Some(append);
             try_call!(raw::git_submodule_foreach(
                 self.raw,
-                append,
+                cb,
                 &mut data as *mut _ as *mut c_void
             ));
         }
@@ -2426,9 +2427,10 @@ impl Repository {
             let mut data = StashCbData {
                 callback: &mut callback,
             };
+            let cb: raw::git_stash_cb = Some(stash_cb);
             try_call!(raw::git_stash_foreach(
                 self.raw(),
-                stash_cb,
+                cb,
                 &mut data as *mut _ as *mut _
             ));
             Ok(())
diff --git a/src/transport.rs b/src/transport.rs
@@ -113,11 +113,8 @@ where
     });
     let prefix = CString::new(prefix)?;
     let datap = (&mut *data) as *mut TransportData as *mut c_void;
-    try_call!(raw::git_transport_register(
-        prefix,
-        transport_factory,
-        datap
-    ));
+    let factory: raw::git_transport_cb = Some(transport_factory);
+    try_call!(raw::git_transport_register(prefix, factory, datap));
     mem::forget(data);
     Ok(())
 }
@@ -141,9 +138,9 @@ impl Transport {
 
         let mut raw = Box::new(RawSmartSubtransport {
             raw: raw::git_smart_subtransport {
-                action: subtransport_action,
-                close: subtransport_close,
-                free: subtransport_free,
+                action: Some(subtransport_action),
+                close: Some(subtransport_close),
+                free: Some(subtransport_free),
             },
             obj: Box::new(subtransport),
         });
@@ -257,9 +254,9 @@ extern "C" fn subtransport_action(
         *stream = mem::transmute(Box::new(RawSmartSubtransportStream {
             raw: raw::git_smart_subtransport_stream {
                 subtransport: raw_transport,
-                read: stream_read,
-                write: stream_write,
-                free: stream_free,
+                read: Some(stream_read),
+                write: Some(stream_write),
+                free: Some(stream_free),
             },
             obj: obj,
         }));
diff --git a/src/tree.rs b/src/tree.rs
@@ -132,7 +132,7 @@ impl<'repo> Tree<'repo> {
             raw::git_tree_walk(
                 self.raw(),
                 mode.into(),
-                treewalk_cb::<T>,
+                Some(treewalk_cb::<T>),
                 &mut data as *mut _ as *mut c_void,
             );
             Ok(())
diff --git a/src/treebuilder.rs b/src/treebuilder.rs
@@ -95,12 +95,9 @@ impl<'repo> TreeBuilder<'repo> {
     {
         let mut cb: &mut FilterCb<'_> = &mut filter;
         let ptr = &mut cb as *mut _;
+        let cb: raw::git_treebuilder_filter_cb = Some(filter_cb);
         unsafe {
-            try_call!(raw::git_treebuilder_filter(
-                self.raw,
-                filter_cb,
-                ptr as *mut _
-            ));
+            try_call!(raw::git_treebuilder_filter(self.raw, cb, ptr as *mut _));
             panic::check();
         }
         Ok(())

Original file line number	Diff line number	Diff line change
`@@ -124,19 +124,27 @@ impl<'repo> Drop for BlobWriter<'repo> {`
`124`	`124`	`fn drop(&mut self) {`
`125`	`125`	`// We need cleanup in case the stream has not been committed`
`126`	`126`	`if self.need_cleanup {`
`127`		`- unsafe { ((*self.raw).free)(self.raw) }`
	`127`	`+ unsafe {`
	`128`	`+ if let Some(f) = (*self.raw).free {`
	`129`	`+ f(self.raw)`
	`130`	`+ }`
	`131`	`+ }`
`128`	`132`	`}`
`129`	`133`	`}`
`130`	`134`	`}`
`131`	`135`
`132`	`136`	`impl<'repo> io::Write for BlobWriter<'repo> {`
`133`	`137`	`fn write(&mut self, buf: &[u8]) -> io::Result<usize> {`
`134`	`138`	`unsafe {`
`135`		`- let res = ((self.raw).write)(self.raw, buf.as_ptr() as const _, buf.len());`
`136`		`- if res < 0 {`
`137`		`- Err(io::Error::new(io::ErrorKind::Other, "Write error"))`
	`139`	`+ if let Some(f) = (*self.raw).write {`
	`140`	`+ let res = f(self.raw, buf.as_ptr() as *const _, buf.len());`
	`141`	`+ if res < 0 {`
	`142`	`+ Err(io::Error::new(io::ErrorKind::Other, "Write error"))`
	`143`	`+ } else {`
	`144`	`+ Ok(buf.len())`
	`145`	`+ }`
`138`	`146`	`} else {`
`139`		`- Ok(buf.len())`
	`147`	`+ Err(io::Error::new(io::ErrorKind::Other, "no write callback"))`
`140`	`148`	`}`
`141`	`149`	`}`
`142`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -589,13 +589,11 @@ impl<'cb> CheckoutBuilder<'cb> {`
`589`	`589`	`opts.their_label = c.as_ptr();`
`590`	`590`	`}`
`591`	`591`	`if self.progress.is_some() {`
`592`		`- let f: raw::git_checkout_progress_cb = progress_cb;`
`593`		`- opts.progress_cb = Some(f);`
	`592`	`+ opts.progress_cb = Some(progress_cb);`
`594`	`593`	`opts.progress_payload = self as mut _ as mut _;`
`595`	`594`	`}`
`596`	`595`	`if self.notify.is_some() {`
`597`		`- let f: raw::git_checkout_notify_cb = notify_cb;`
`598`		`- opts.notify_cb = Some(f);`
	`596`	`+ opts.notify_cb = Some(notify_cb);`
`599`	`597`	`opts.notify_payload = self as mut _ as mut _;`
`600`	`598`	`opts.notify_flags = self.notify_flags.bits() as c_uint;`
`601`	`599`	`}`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,11 @@ impl Binding for Cred {`
`179`	`179`	`impl Drop for Cred {`
`180`	`180`	`fn drop(&mut self) {`
`181`	`181`	`if !self.raw.is_null() {`
`182`		`- unsafe { ((*self.raw).free)(self.raw) }`
	`182`	`+ unsafe {`
	`183`	`+ if let Some(f) = (*self.raw).free {`
	`184`	`+ f(self.raw)`
	`185`	`+ }`
	`186`	`+ }`
`183`	`187`	`}`
`184`	`188`	`}`
`185`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -206,7 +206,8 @@ impl<'buffers> Patch<'buffers> {`
`206`	`206`	`pub fn print(&mut self, mut line_cb: &mut LineCb<'_>) -> Result<(), Error> {`
`207`	`207`	`let ptr = &mut line_cb as mut _ as mut c_void;`
`208`	`208`	`unsafe {`
`209`		`- try_call!(raw::git_patch_print(self.raw, print_cb, ptr));`
	`209`	`+ let cb: raw::git_diff_line_cb = Some(print_cb);`
	`210`	`+ try_call!(raw::git_patch_print(self.raw, cb, ptr));`
`210`	`211`	`Ok(())`
`211`	`212`	`}`
`212`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -174,24 +174,19 @@ impl<'a> Binding for RemoteCallbacks<'a> {`
`174`	`174`	`0`
`175`	`175`	`);`
`176`	`176`	`if self.progress.is_some() {`
`177`		`- let f: raw::git_indexer_progress_cb = transfer_progress_cb;`
`178`		`- callbacks.transfer_progress = Some(f);`
	`177`	`+ callbacks.transfer_progress = Some(transfer_progress_cb);`
`179`	`178`	`}`
`180`	`179`	`if self.credentials.is_some() {`
`181`		`- let f: raw::git_cred_acquire_cb = credentials_cb;`
`182`		`- callbacks.credentials = Some(f);`
	`180`	`+ callbacks.credentials = Some(credentials_cb);`
`183`	`181`	`}`
`184`	`182`	`if self.sideband_progress.is_some() {`
`185`		`- let f: raw::git_transport_message_cb = sideband_progress_cb;`
`186`		`- callbacks.sideband_progress = Some(f);`
	`183`	`+ callbacks.sideband_progress = Some(sideband_progress_cb);`
`187`	`184`	`}`
`188`	`185`	`if self.certificate_check.is_some() {`
`189`		`- let f: raw::git_transport_certificate_check_cb = certificate_check_cb;`
`190`		`- callbacks.certificate_check = Some(f);`
	`186`	`+ callbacks.certificate_check = Some(certificate_check_cb);`
`191`	`187`	`}`
`192`	`188`	`if self.push_update_reference.is_some() {`
`193`		`- let f: extern "C" fn(_, _, _) -> c_int = push_update_reference_cb;`
`194`		`- callbacks.push_update_reference = Some(f);`
	`189`	`+ callbacks.push_update_reference = Some(push_update_reference_cb);`
`195`	`190`	`}`
`196`	`191`	`if self.update_tips.is_some() {`
`197`	`192`	`let f: extern "C" fn(`