from_parts should be unsafe

Morganamilo · Morganamilo · commit 6a39c87137ff · 2021-12-09T22:56:17.000Z
diff --git a/alpm/src/conflict.rs b/alpm/src/conflict.rs
@@ -188,7 +188,7 @@ impl Alpm {
     ) -> AlpmListMut<OwnedConflict> {
         let list = unsafe { list.into_raw_alpm_list() };
         let ret = unsafe { alpm_checkconflicts(self.as_ptr(), list.list()) };
-        AlpmListMut::from_parts(self, ret)
+        unsafe { AlpmListMut::from_parts(self, ret) }
     }
 }
 
diff --git a/alpm/src/db.rs b/alpm/src/db.rs
@@ -109,7 +109,7 @@ impl<'h> Db<'h> {
 
     pub fn servers(&self) -> AlpmList<'h, &'h str> {
         let list = unsafe { alpm_db_get_servers(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn pkg<S: Into<Vec<u8>>>(&self, name: S) -> Result<Package<'h>> {
@@ -122,7 +122,7 @@ impl<'h> Db<'h> {
     #[doc(alias = "pkgcache")]
     pub fn pkgs(&self) -> AlpmList<'h, Package<'h>> {
         let pkgs = unsafe { alpm_db_get_pkgcache(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, pkgs)
+        unsafe { AlpmList::from_parts(self.handle, pkgs) }
     }
 
     pub fn group<S: Into<Vec<u8>>>(&self, name: S) -> Result<Group<'h>> {
@@ -145,14 +145,14 @@ impl<'h> Db<'h> {
         let list = unsafe { list.into_raw_alpm_list() };
         let ok = unsafe { alpm_db_search(self.as_ptr(), list.list(), &mut ret) };
         self.handle.check_ret(ok)?;
-        Ok(AlpmListMut::from_parts(self.handle, ret))
+        unsafe { Ok(AlpmListMut::from_parts(self.handle, ret)) }
     }
 
     #[doc(alias = "groupcache")]
     pub fn groups(&self) -> Result<AlpmListMut<'h, Group<'h>>> {
         let groups = unsafe { alpm_db_get_groupcache(self.as_ptr()) };
         self.handle.check_null(groups)?;
-        Ok(AlpmListMut::from_parts(self.handle, groups))
+        unsafe { Ok(AlpmListMut::from_parts(self.handle, groups)) }
     }
 
     pub fn siglevel(&self) -> SigLevel {
diff --git a/alpm/src/deps.rs b/alpm/src/deps.rs
@@ -363,7 +363,7 @@ impl Alpm {
                 reverse_deps,
             )
         };
-        AlpmListMut::from_parts(self, ret)
+        unsafe { AlpmListMut::from_parts(self, ret) }
     }
 }
 
diff --git a/alpm/src/dload.rs b/alpm/src/dload.rs
@@ -13,7 +13,7 @@ impl Alpm {
         let list = unsafe { urls.into_raw_alpm_list() };
         let ret = unsafe { alpm_fetch_pkgurl(self.as_ptr(), list.list(), &mut out) };
         self.check_ret(ret)?;
-        let fetched = AlpmListMut::from_parts(self, out);
+        let fetched = unsafe { AlpmListMut::from_parts(self, out) };
         Ok(fetched)
     }
 }
diff --git a/alpm/src/handle.rs b/alpm/src/handle.rs
@@ -27,12 +27,12 @@ impl Alpm {
 
     pub fn hookdirs(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_hookdirs(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn cachedirs(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_cachedirs(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn lockfile(&self) -> &str {
@@ -49,37 +49,37 @@ impl Alpm {
 
     pub fn noupgrades(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_noupgrades(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn noextracts(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_noextracts(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn ignorepkgs(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_ignorepkgs(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn ignoregroups(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_ignoregroups(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn overwrite_files(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_overwrite_files(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn assume_installed(&self) -> AlpmList<'_, Depend> {
         let list = unsafe { alpm_option_get_assumeinstalled(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn architectures(&self) -> AlpmList<'_, &str> {
         let list = unsafe { alpm_option_get_architectures(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn check_space(&self) -> bool {
@@ -348,12 +348,12 @@ impl Alpm {
 
     pub fn syncdbs(&self) -> AlpmList<Db> {
         let dbs = unsafe { alpm_get_syncdbs(self.as_ptr()) };
-        AlpmList::from_parts(self, dbs)
+        unsafe { AlpmList::from_parts(self, dbs) }
     }
 
     pub fn syncdbs_mut(&mut self) -> AlpmList<DbMut> {
         let dbs = unsafe { alpm_get_syncdbs(self.as_ptr()) };
-        AlpmList::from_parts(self, dbs)
+        unsafe { AlpmList::from_parts(self, dbs) }
     }
 
     pub fn set_check_space(&self, b: bool) {
diff --git a/alpm/src/list.rs b/alpm/src/list.rs
@@ -265,7 +265,7 @@ where
 
 impl<'a> AlpmList<'a, String> {
     pub fn as_str<'b>(&'b self) -> AlpmList<'a, &'b str> {
-        AlpmList::from_parts(self.handle, self.list)
+        unsafe { AlpmList::from_parts(self.handle, self.list) }
     }
 }
 
@@ -277,7 +277,7 @@ where
     pub fn to_list_mut(&self) -> AlpmListMut<'a, T> {
         let list = unsafe { alpm_list_copy(self.list) };
         AlpmListMut {
-            list: AlpmList::from_parts(self.handle, list),
+            list: unsafe { AlpmList::from_parts(self.handle, list) },
         }
     }
 }
@@ -365,7 +365,7 @@ where
         self.list.list = unsafe { alpm_list_remove_item(self.list.list, item) };
         unsafe { (*item).next = ptr::null_mut() };
         unsafe { (*item).prev = ptr::null_mut() };
-        AlpmListMut::from_parts(self.handle, item)
+        unsafe { AlpmListMut::from_parts(self.handle, item) }
     }
 
     pub fn as_list(&self) -> AlpmList<'a, T> {
@@ -504,7 +504,7 @@ where
     for<'b> T: IntoAlpmListItem<'a, 'b>,
 {
     fn drop(&mut self) {
-        AlpmListMut::<T>::from_parts(self.list.handle, self.current);
+        unsafe { AlpmListMut::<T>::from_parts(self.list.handle, self.current) };
     }
 }
 
@@ -605,7 +605,7 @@ where
 }
 
 impl<'a, T> AlpmList<'a, T> {
-    pub(crate) fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmList<'a, T> {
+    pub(crate) unsafe fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmList<'a, T> {
         AlpmList {
             handle,
             list,
@@ -620,11 +620,14 @@ where
 {
     pub fn new(handle: &'a Alpm) -> AlpmListMut<'a, T> {
         AlpmListMut {
-            list: AlpmList::from_parts(handle, ptr::null_mut()),
+            list: unsafe { AlpmList::from_parts(handle, ptr::null_mut()) },
         }
     }
 
-    pub(crate) fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmListMut<'a, T> {
+    pub(crate) unsafe fn from_parts(
+        handle: &'a Alpm,
+        list: *mut alpm_list_t,
+    ) -> AlpmListMut<'a, T> {
         AlpmListMut {
             list: AlpmList::from_parts(handle, list),
         }
diff --git a/alpm/src/package.rs b/alpm/src/package.rs
@@ -187,47 +187,47 @@ impl<'h> Pkg<'h> {
 
     pub fn licenses(&self) -> AlpmList<'h, &'h str> {
         let list = unsafe { alpm_pkg_get_licenses(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn groups(&self) -> AlpmList<'h, &'h str> {
         let list = unsafe { alpm_pkg_get_groups(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn depends(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_depends(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn optdepends(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_optdepends(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn checkdepends(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_checkdepends(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn makedepends(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_makedepends(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn conflicts(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_conflicts(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn provides(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_provides(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn replaces(&self) -> AlpmList<'h, Dep<'h>> {
         let list = unsafe { alpm_pkg_get_replaces(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn files(&self) -> FileList {
@@ -237,7 +237,7 @@ impl<'h> Pkg<'h> {
 
     pub fn backup(&self) -> AlpmList<'h, Backup> {
         let list = unsafe { alpm_pkg_get_backup(self.as_ptr()) };
-        AlpmList::from_parts(self.handle, list)
+        unsafe { AlpmList::from_parts(self.handle, list) }
     }
 
     pub fn db(&self) -> Option<Db<'h>> {
@@ -265,12 +265,12 @@ impl<'h> Pkg<'h> {
 
     pub fn required_by(&self) -> AlpmListMut<'h, String> {
         let list = unsafe { alpm_pkg_compute_requiredby(self.as_ptr()) };
-        AlpmListMut::from_parts(self.handle, list)
+        unsafe { AlpmListMut::from_parts(self.handle, list) }
     }
 
     pub fn optional_for(&self) -> AlpmListMut<'h, String> {
         let list = unsafe { alpm_pkg_compute_optionalfor(self.as_ptr()) };
-        AlpmListMut::from_parts(self.handle, list)
+        unsafe { AlpmListMut::from_parts(self.handle, list) }
     }
 
     pub fn base64_sig(&self) -> Option<&'h str> {
diff --git a/alpm/src/signing.rs b/alpm/src/signing.rs
@@ -238,6 +238,6 @@ impl Alpm {
         };
 
         self.check_ret(ret)?;
-        Ok(AlpmListMut::from_parts(self, keys))
+        unsafe { Ok(AlpmListMut::from_parts(self, keys)) }
     }
 }
diff --git a/alpm/src/sync.rs b/alpm/src/sync.rs
@@ -30,7 +30,7 @@ impl Alpm {
     ) -> AlpmListMut<'a, Package<'a>> {
         let name = CString::new(s).unwrap();
         let ret = unsafe { alpm_find_group_pkgs(dbs.list, name.as_ptr()) };
-        AlpmListMut::from_parts(self, ret)
+        unsafe { AlpmListMut::from_parts(self, ret) }
     }
 }
 
diff --git a/alpm/src/trans.rs b/alpm/src/trans.rs
@@ -43,15 +43,15 @@ impl Alpm {
 
         if let Err(err) = err {
             let ret = match err {
-                Error::PkgInvalidArch => {
+                Error::PkgInvalidArch => unsafe {
                     PrepareResult::PkgInvalidArch(AlpmListMut::from_parts(self, list))
-                }
-                Error::UnsatisfiedDeps => {
+                },
+                Error::UnsatisfiedDeps => unsafe {
                     PrepareResult::UnsatisfiedDeps(AlpmListMut::from_parts(self, list))
-                }
-                Error::ConflictingDeps => {
+                },
+                Error::ConflictingDeps => unsafe {
                     PrepareResult::ConflictingDeps(AlpmListMut::from_parts(self, list))
-                }
+                },
                 _ => PrepareResult::Ok,
             };
 
@@ -68,12 +68,12 @@ impl Alpm {
 
         if let Err(err) = err {
             let ret = match err {
-                Error::FileConflicts => {
+                Error::FileConflicts => unsafe {
                     CommitResult::FileConflict(AlpmListMut::from_parts(self, list))
-                }
-                Error::PkgInvalid | Error::PkgInvalidSig | Error::PkgInvalidChecksum => {
+                },
+                Error::PkgInvalid | Error::PkgInvalidSig | Error::PkgInvalidChecksum => unsafe {
                     CommitResult::PkgInvalid(AlpmListMut::from_parts(self, list))
-                }
+                },
                 _ => CommitResult::Ok,
             };
 
@@ -90,12 +90,12 @@ impl Alpm {
 
     pub fn trans_add(&self) -> AlpmList<Package> {
         let list = unsafe { alpm_trans_get_add(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn trans_remove(&self) -> AlpmList<Package> {
         let list = unsafe { alpm_trans_get_remove(self.as_ptr()) };
-        AlpmList::from_parts(self, list)
+        unsafe { AlpmList::from_parts(self, list) }
     }
 
     pub fn trans_release(&mut self) -> Result<()> {
diff --git a/alpm/src/types.rs b/alpm/src/types.rs
@@ -917,7 +917,7 @@ impl<'a> RemovePkgsQuestion<'a> {
 
     pub fn packages(&'a self) -> AlpmList<'a, Package> {
         let list = unsafe { (*self.inner).packages };
-        AlpmList::from_parts(&self.handle, list)
+        unsafe { AlpmList::from_parts(&self.handle, list) }
     }
 }
 
@@ -934,7 +934,7 @@ impl<'a> SelectProviderQuestion<'a> {
 
     pub fn providers(&self) -> AlpmList<Package> {
         let list = unsafe { (*self.inner).providers };
-        AlpmList::from_parts(&self.handle, list)
+        unsafe { AlpmList::from_parts(&self.handle, list) }
     }
 
     pub fn depend(&self) -> Dep {
@@ -1006,7 +1006,7 @@ impl<'a> Group<'a> {
 
     pub fn packages(&self) -> AlpmList<'a, Package<'a>> {
         let pkgs = unsafe { (*self.as_ptr()).packages };
-        AlpmList::from_parts(self.handle, pkgs)
+        unsafe { AlpmList::from_parts(self.handle, pkgs) }
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ impl Alpm {`
`188`	`188`	`) -> AlpmListMut<OwnedConflict> {`
`189`	`189`	`let list = unsafe { list.into_raw_alpm_list() };`
`190`	`190`	`let ret = unsafe { alpm_checkconflicts(self.as_ptr(), list.list()) };`
`191`		`- AlpmListMut::from_parts(self, ret)`
	`191`	`+ unsafe { AlpmListMut::from_parts(self, ret) }`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
Original file line number	Diff line number	Diff line change
`@@ -363,7 +363,7 @@ impl Alpm {`
`363`	`363`	`reverse_deps,`
`364`	`364`	`)`
`365`	`365`	`};`
`366`		`- AlpmListMut::from_parts(self, ret)`
	`366`	`+ unsafe { AlpmListMut::from_parts(self, ret) }`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ impl Alpm {`
`13`	`13`	`let list = unsafe { urls.into_raw_alpm_list() };`
`14`	`14`	`let ret = unsafe { alpm_fetch_pkgurl(self.as_ptr(), list.list(), &mut out) };`
`15`	`15`	`self.check_ret(ret)?;`
`16`		`- let fetched = AlpmListMut::from_parts(self, out);`
	`16`	`+ let fetched = unsafe { AlpmListMut::from_parts(self, out) };`
`17`	`17`	`Ok(fetched)`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,12 @@ impl Alpm {`
`27`	`27`
`28`	`28`	`pub fn hookdirs(&self) -> AlpmList<'_, &str> {`
`29`	`29`	`let list = unsafe { alpm_option_get_hookdirs(self.as_ptr()) };`
`30`		`- AlpmList::from_parts(self, list)`
	`30`	`+ unsafe { AlpmList::from_parts(self, list) }`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`pub fn cachedirs(&self) -> AlpmList<'_, &str> {`
`34`	`34`	`let list = unsafe { alpm_option_get_cachedirs(self.as_ptr()) };`
`35`		`- AlpmList::from_parts(self, list)`
	`35`	`+ unsafe { AlpmList::from_parts(self, list) }`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`pub fn lockfile(&self) -> &str {`
`@@ -49,37 +49,37 @@ impl Alpm {`
`49`	`49`
`50`	`50`	`pub fn noupgrades(&self) -> AlpmList<'_, &str> {`
`51`	`51`	`let list = unsafe { alpm_option_get_noupgrades(self.as_ptr()) };`
`52`		`- AlpmList::from_parts(self, list)`
	`52`	`+ unsafe { AlpmList::from_parts(self, list) }`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`pub fn noextracts(&self) -> AlpmList<'_, &str> {`
`56`	`56`	`let list = unsafe { alpm_option_get_noextracts(self.as_ptr()) };`
`57`		`- AlpmList::from_parts(self, list)`
	`57`	`+ unsafe { AlpmList::from_parts(self, list) }`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`pub fn ignorepkgs(&self) -> AlpmList<'_, &str> {`
`61`	`61`	`let list = unsafe { alpm_option_get_ignorepkgs(self.as_ptr()) };`
`62`		`- AlpmList::from_parts(self, list)`
	`62`	`+ unsafe { AlpmList::from_parts(self, list) }`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`pub fn ignoregroups(&self) -> AlpmList<'_, &str> {`
`66`	`66`	`let list = unsafe { alpm_option_get_ignoregroups(self.as_ptr()) };`
`67`		`- AlpmList::from_parts(self, list)`
	`67`	`+ unsafe { AlpmList::from_parts(self, list) }`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`pub fn overwrite_files(&self) -> AlpmList<'_, &str> {`
`71`	`71`	`let list = unsafe { alpm_option_get_overwrite_files(self.as_ptr()) };`
`72`		`- AlpmList::from_parts(self, list)`
	`72`	`+ unsafe { AlpmList::from_parts(self, list) }`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`pub fn assume_installed(&self) -> AlpmList<'_, Depend> {`
`76`	`76`	`let list = unsafe { alpm_option_get_assumeinstalled(self.as_ptr()) };`
`77`		`- AlpmList::from_parts(self, list)`
	`77`	`+ unsafe { AlpmList::from_parts(self, list) }`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`pub fn architectures(&self) -> AlpmList<'_, &str> {`
`81`	`81`	`let list = unsafe { alpm_option_get_architectures(self.as_ptr()) };`
`82`		`- AlpmList::from_parts(self, list)`
	`82`	`+ unsafe { AlpmList::from_parts(self, list) }`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`pub fn check_space(&self) -> bool {`
`@@ -348,12 +348,12 @@ impl Alpm {`
`348`	`348`
`349`	`349`	`pub fn syncdbs(&self) -> AlpmList<Db> {`
`350`	`350`	`let dbs = unsafe { alpm_get_syncdbs(self.as_ptr()) };`
`351`		`- AlpmList::from_parts(self, dbs)`
	`351`	`+ unsafe { AlpmList::from_parts(self, dbs) }`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`pub fn syncdbs_mut(&mut self) -> AlpmList<DbMut> {`
`355`	`355`	`let dbs = unsafe { alpm_get_syncdbs(self.as_ptr()) };`
`356`		`- AlpmList::from_parts(self, dbs)`
	`356`	`+ unsafe { AlpmList::from_parts(self, dbs) }`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`pub fn set_check_space(&self, b: bool) {`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ where`
`265`	`265`
`266`	`266`	`impl<'a> AlpmList<'a, String> {`
`267`	`267`	`pub fn as_str<'b>(&'b self) -> AlpmList<'a, &'b str> {`
`268`		`- AlpmList::from_parts(self.handle, self.list)`
	`268`	`+ unsafe { AlpmList::from_parts(self.handle, self.list) }`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`
`@@ -277,7 +277,7 @@ where`
`277`	`277`	`pub fn to_list_mut(&self) -> AlpmListMut<'a, T> {`
`278`	`278`	`let list = unsafe { alpm_list_copy(self.list) };`
`279`	`279`	`AlpmListMut {`
`280`		`- list: AlpmList::from_parts(self.handle, list),`
	`280`	`+ list: unsafe { AlpmList::from_parts(self.handle, list) },`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`	`}`
`@@ -365,7 +365,7 @@ where`
`365`	`365`	`self.list.list = unsafe { alpm_list_remove_item(self.list.list, item) };`
`366`	`366`	`unsafe { (*item).next = ptr::null_mut() };`
`367`	`367`	`unsafe { (*item).prev = ptr::null_mut() };`
`368`		`- AlpmListMut::from_parts(self.handle, item)`
	`368`	`+ unsafe { AlpmListMut::from_parts(self.handle, item) }`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`pub fn as_list(&self) -> AlpmList<'a, T> {`
`@@ -504,7 +504,7 @@ where`
`504`	`504`	`for<'b> T: IntoAlpmListItem<'a, 'b>,`
`505`	`505`	`{`
`506`	`506`	`fn drop(&mut self) {`
`507`		`- AlpmListMut::<T>::from_parts(self.list.handle, self.current);`
	`507`	`+ unsafe { AlpmListMut::<T>::from_parts(self.list.handle, self.current) };`
`508`	`508`	`}`
`509`	`509`	`}`
`510`	`510`
`@@ -605,7 +605,7 @@ where`
`605`	`605`	`}`
`606`	`606`
`607`	`607`	`impl<'a, T> AlpmList<'a, T> {`
`608`		`- pub(crate) fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmList<'a, T> {`
	`608`	`+ pub(crate) unsafe fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmList<'a, T> {`
`609`	`609`	`AlpmList {`
`610`	`610`	`handle,`
`611`	`611`	`list,`
`@@ -620,11 +620,14 @@ where`
`620`	`620`	`{`
`621`	`621`	`pub fn new(handle: &'a Alpm) -> AlpmListMut<'a, T> {`
`622`	`622`	`AlpmListMut {`
`623`		`- list: AlpmList::from_parts(handle, ptr::null_mut()),`
	`623`	`+ list: unsafe { AlpmList::from_parts(handle, ptr::null_mut()) },`
`624`	`624`	`}`
`625`	`625`	`}`
`626`	`626`
`627`		`- pub(crate) fn from_parts(handle: &'a Alpm, list: *mut alpm_list_t) -> AlpmListMut<'a, T> {`
	`627`	`+ pub(crate) unsafe fn from_parts(`
	`628`	`+ handle: &'a Alpm,`
	`629`	`+ list: *mut alpm_list_t,`
	`630`	`+ ) -> AlpmListMut<'a, T> {`
`628`	`631`	`AlpmListMut {`
`629`	`632`	`list: AlpmList::from_parts(handle, list),`
`630`	`633`	`}`
Original file line number	Diff line number	Diff line change
`@@ -187,47 +187,47 @@ impl<'h> Pkg<'h> {`
`187`	`187`
`188`	`188`	`pub fn licenses(&self) -> AlpmList<'h, &'h str> {`
`189`	`189`	`let list = unsafe { alpm_pkg_get_licenses(self.as_ptr()) };`
`190`		`- AlpmList::from_parts(self.handle, list)`
	`190`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`pub fn groups(&self) -> AlpmList<'h, &'h str> {`
`194`	`194`	`let list = unsafe { alpm_pkg_get_groups(self.as_ptr()) };`
`195`		`- AlpmList::from_parts(self.handle, list)`
	`195`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`pub fn depends(&self) -> AlpmList<'h, Dep<'h>> {`
`199`	`199`	`let list = unsafe { alpm_pkg_get_depends(self.as_ptr()) };`
`200`		`- AlpmList::from_parts(self.handle, list)`
	`200`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`pub fn optdepends(&self) -> AlpmList<'h, Dep<'h>> {`
`204`	`204`	`let list = unsafe { alpm_pkg_get_optdepends(self.as_ptr()) };`
`205`		`- AlpmList::from_parts(self.handle, list)`
	`205`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`pub fn checkdepends(&self) -> AlpmList<'h, Dep<'h>> {`
`209`	`209`	`let list = unsafe { alpm_pkg_get_checkdepends(self.as_ptr()) };`
`210`		`- AlpmList::from_parts(self.handle, list)`
	`210`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`pub fn makedepends(&self) -> AlpmList<'h, Dep<'h>> {`
`214`	`214`	`let list = unsafe { alpm_pkg_get_makedepends(self.as_ptr()) };`
`215`		`- AlpmList::from_parts(self.handle, list)`
	`215`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`pub fn conflicts(&self) -> AlpmList<'h, Dep<'h>> {`
`219`	`219`	`let list = unsafe { alpm_pkg_get_conflicts(self.as_ptr()) };`
`220`		`- AlpmList::from_parts(self.handle, list)`
	`220`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`pub fn provides(&self) -> AlpmList<'h, Dep<'h>> {`
`224`	`224`	`let list = unsafe { alpm_pkg_get_provides(self.as_ptr()) };`
`225`		`- AlpmList::from_parts(self.handle, list)`
	`225`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`pub fn replaces(&self) -> AlpmList<'h, Dep<'h>> {`
`229`	`229`	`let list = unsafe { alpm_pkg_get_replaces(self.as_ptr()) };`
`230`		`- AlpmList::from_parts(self.handle, list)`
	`230`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`pub fn files(&self) -> FileList {`
`@@ -237,7 +237,7 @@ impl<'h> Pkg<'h> {`
`237`	`237`
`238`	`238`	`pub fn backup(&self) -> AlpmList<'h, Backup> {`
`239`	`239`	`let list = unsafe { alpm_pkg_get_backup(self.as_ptr()) };`
`240`		`- AlpmList::from_parts(self.handle, list)`
	`240`	`+ unsafe { AlpmList::from_parts(self.handle, list) }`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`pub fn db(&self) -> Option<Db<'h>> {`
`@@ -265,12 +265,12 @@ impl<'h> Pkg<'h> {`
`265`	`265`
`266`	`266`	`pub fn required_by(&self) -> AlpmListMut<'h, String> {`
`267`	`267`	`let list = unsafe { alpm_pkg_compute_requiredby(self.as_ptr()) };`
`268`		`- AlpmListMut::from_parts(self.handle, list)`
	`268`	`+ unsafe { AlpmListMut::from_parts(self.handle, list) }`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`pub fn optional_for(&self) -> AlpmListMut<'h, String> {`
`272`	`272`	`let list = unsafe { alpm_pkg_compute_optionalfor(self.as_ptr()) };`
`273`		`- AlpmListMut::from_parts(self.handle, list)`
	`273`	`+ unsafe { AlpmListMut::from_parts(self.handle, list) }`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`pub fn base64_sig(&self) -> Option<&'h str> {`
Original file line number	Diff line number	Diff line change
`@@ -238,6 +238,6 @@ impl Alpm {`
`238`	`238`	`};`
`239`	`239`
`240`	`240`	`self.check_ret(ret)?;`
`241`		`- Ok(AlpmListMut::from_parts(self, keys))`
	`241`	`+ unsafe { Ok(AlpmListMut::from_parts(self, keys)) }`
`242`	`242`	`}`
`243`	`243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ impl Alpm {`
`30`	`30`	`) -> AlpmListMut<'a, Package<'a>> {`
`31`	`31`	`let name = CString::new(s).unwrap();`
`32`	`32`	`let ret = unsafe { alpm_find_group_pkgs(dbs.list, name.as_ptr()) };`
`33`		`- AlpmListMut::from_parts(self, ret)`
	`33`	`+ unsafe { AlpmListMut::from_parts(self, ret) }`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`