Remove lifetime anchors in from_raw functions

These ended up not pulling their weight and the types weren't always available.
They're all unsafe already so they're sadly just a little more unsafe now, but
probably not called from a public setting.

Also renames a lot of lifetimes to be more specific as to what they're
referencing.

Author: alexcrichton

src/blob.rs

@@ -2,25 +2,24 @@ use std::kinds::marker;
 use std::mem;
 use std::raw as stdraw;
 
-use {raw, Oid, Repository};
+use {raw, Oid};
 
 /// A structure to represent a git [blob][1]
 ///
 /// [1]: http://git-scm.com/book/en/Git-Internals-Git-Objects
-pub struct Blob<'a> {
+pub struct Blob<'repo> {
     raw: *mut raw::git_blob,
-    marker1: marker::ContravariantLifetime<'a>,
+    marker1: marker::ContravariantLifetime<'repo>,
     marker2: marker::NoSend,
     marker3: marker::NoSync,
 }
 
-impl<'a> Blob<'a> {
+impl<'repo> Blob<'repo> {
     /// Create a new object from its raw component.
     ///
     /// This method is unsafe as there is no guarantee that `raw` is a valid
     /// pointer.
-    pub unsafe fn from_raw(_repo: &Repository,
-                           raw: *mut raw::git_blob) -> Blob {
+    pub unsafe fn from_raw(raw: *mut raw::git_blob) -> Blob<'repo> {
         Blob {
             raw: raw,
             marker1: marker::ContravariantLifetime,
@@ -54,7 +53,7 @@ impl<'a> Blob<'a> {
 }
 
 #[unsafe_destructor]
-impl<'a> Drop for Blob<'a> {
+impl<'repo> Drop for Blob<'repo> {
     fn drop(&mut self) {
         unsafe { raw::git_blob_free(self.raw) }
     }

src/branch.rs

@@ -1,7 +1,8 @@
+use std::kinds::marker;
 use std::str;
 use libc;
 
-use {raw, Repository, Error, Reference, Signature, BranchType};
+use {raw, Error, Reference, Signature, BranchType};
 
 /// A structure to represent a git [branch][1]
 ///
@@ -15,8 +16,10 @@ pub struct Branch<'repo> {
 
 /// An iterator over the branches inside of a repository.
 pub struct Branches<'repo> {
-    repo: &'repo Repository,
     raw: *mut raw::git_branch_iterator,
+    marker1: marker::ContravariantLifetime<'repo>,
+    marker2: marker::NoSend,
+    marker3: marker::NoSync,
 }
 
 impl<'repo> Branch<'repo> {
@@ -52,7 +55,7 @@ impl<'repo> Branch<'repo> {
                                            &*signature.map(|s| s.raw())
                                                       .unwrap_or(0 as *mut _),
                                            log_message.to_c_str()));
-            Ok(Branch::wrap(Reference::from_raw_ptr(ret)))
+            Ok(Branch::wrap(Reference::from_raw(ret)))
         }
     }
 
@@ -78,7 +81,7 @@ impl<'repo> Branch<'repo> {
         let mut ret = 0 as *mut raw::git_reference;
         unsafe {
             try_call!(raw::git_branch_upstream(&mut ret, &*self.get().raw()));
-            Ok(Branch::wrap(Reference::from_raw_ptr(ret)))
+            Ok(Branch::wrap(Reference::from_raw(ret)))
         }
     }
 
@@ -97,19 +100,24 @@ impl<'repo> Branch<'repo> {
     }
 }
 
-impl<'a> Branches<'a> {
+impl<'repo> Branches<'repo> {
     /// Creates a new iterator from the raw pointer given.
     ///
     /// This function is unsafe as it is not guaranteed that `raw` is a valid
     /// pointer.
-    pub unsafe fn from_raw(repo: &Repository,
-                           raw: *mut raw::git_branch_iterator) -> Branches {
-        Branches { repo: repo, raw: raw }
+    pub unsafe fn from_raw(raw: *mut raw::git_branch_iterator)
+                           -> Branches<'repo> {
+        Branches {
+            raw: raw,
+            marker1: marker::ContravariantLifetime,
+            marker2: marker::NoSend,
+            marker3: marker::NoSync,
+        }
     }
 }
 
-impl<'a> Iterator<(Branch<'a>, BranchType)> for Branches<'a> {
-    fn next(&mut self) -> Option<(Branch<'a>, BranchType)> {
+impl<'repo> Iterator<(Branch<'repo>, BranchType)> for Branches<'repo> {
+    fn next(&mut self) -> Option<(Branch<'repo>, BranchType)> {
         let mut ret = 0 as *mut raw::git_reference;
         let mut typ = raw::GIT_BRANCH_LOCAL;
         unsafe {
@@ -123,13 +131,13 @@ impl<'a> Iterator<(Branch<'a>, BranchType)> for Branches<'a> {
                 raw::GIT_BRANCH_REMOTE => BranchType::Remote,
                 raw::GIT_BRANCH_ALL => panic!("unexected branch type"),
             };
-            Some((Branch::wrap(Reference::from_raw(self.repo, ret)), typ))
+            Some((Branch::wrap(Reference::from_raw(ret)), typ))
         }
     }
 }
 
 #[unsafe_destructor]
-impl<'a> Drop for Branches<'a> {
+impl<'repo> Drop for Branches<'repo> {
     fn drop(&mut self) {
         unsafe { raw::git_branch_iterator_free(self.raw) }
     }

src/commit.rs

@@ -3,37 +3,36 @@ use std::iter::Range;
 use std::str;
 use libc;
 
-use {raw, Oid, Repository, Error, Signature, Tree, Time};
+use {raw, Oid, Error, Signature, Tree, Time};
 
 /// A structure to represent a git [commit][1]
 ///
 /// [1]: http://git-scm.com/book/en/Git-Internals-Git-Objects
-pub struct Commit<'a> {
+pub struct Commit<'repo> {
     raw: *mut raw::git_commit,
-    marker1: marker::ContravariantLifetime<'a>,
+    marker1: marker::ContravariantLifetime<'repo>,
     marker2: marker::NoSend,
     marker3: marker::NoSync,
 }
 
 /// An iterator over the parent commits of a commit.
-pub struct Parents<'a, 'b:'a> {
+pub struct Parents<'commit, 'repo: 'commit> {
     range: Range<uint>,
-    commit: &'a Commit<'b>,
+    commit: &'commit Commit<'repo>,
 }
 
 /// An iterator over the parent commits' ids of a commit.
-pub struct ParentIds<'a> {
+pub struct ParentIds<'commit> {
     range: Range<uint>,
-    commit: &'a Commit<'a>,
+    commit: &'commit Commit<'commit>,
 }
 
-impl<'a> Commit<'a> {
+impl<'repo> Commit<'repo> {
     /// Create a new object from its raw component.
     ///
     /// This method is unsafe as there is no guarantee that `raw` is a valid
     /// pointer.
-    pub unsafe fn from_raw(_repo: &Repository,
-                           raw: *mut raw::git_commit) -> Commit {
+    pub unsafe fn from_raw(raw: *mut raw::git_commit) -> Commit<'repo> {
         Commit {
             raw: raw,
             marker1: marker::ContravariantLifetime,
@@ -159,7 +158,7 @@ impl<'a> Commit<'a> {
     }
 
     /// Creates a new iterator over the parents of this commit.
-    pub fn parents<'b>(&'b self) -> Parents<'b, 'a> {
+    pub fn parents<'a>(&'a self) -> Parents<'a, 'repo> {
         let max = unsafe { raw::git_commit_parentcount(&*self.raw) as uint };
         Parents {
             range: range(0, max),
@@ -205,7 +204,7 @@ impl<'a> Commit<'a> {
                  committer: Option<&Signature>,
                  message_encoding: Option<&str>,
                  message: Option<&str>,
-                 tree: Option<&Tree<'a>>) -> Result<Oid, Error> {
+                 tree: Option<&Tree<'repo>>) -> Result<Oid, Error> {
         let mut raw = raw::git_oid { id: [0, ..raw::GIT_OID_RAWSZ] };
         unsafe {
             try_call!(raw::git_commit_amend(&mut raw,
@@ -223,17 +222,12 @@ impl<'a> Commit<'a> {
     /// Get the specified parent of the commit.
     ///
     /// Use the `parents` iterator to return an iterator over all parents.
-    pub fn parent(&self, i: uint) -> Result<Commit<'a>, Error> {
+    pub fn parent(&self, i: uint) -> Result<Commit<'repo>, Error> {
         unsafe {
             let mut raw = 0 as *mut raw::git_commit;
             try_call!(raw::git_commit_parent(&mut raw, &*self.raw,
                                              i as libc::c_uint));
-            Ok(Commit {
-                raw: raw,
-                marker1: marker::ContravariantLifetime,
-                marker2: marker::NoSend,
-                marker3: marker::NoSync,
-            })
+            Ok(Commit::from_raw(raw))
         }
     }
 
@@ -255,38 +249,38 @@ impl<'a> Commit<'a> {
     }
 }
 
-impl<'a, 'b> Iterator<Commit<'a>> for Parents<'b, 'a> {
-    fn next(&mut self) -> Option<Commit<'a>> {
+impl<'repo, 'commit> Iterator<Commit<'repo>> for Parents<'commit, 'repo> {
+    fn next(&mut self) -> Option<Commit<'repo>> {
         self.range.next().map(|i| self.commit.parent(i).unwrap())
     }
     fn size_hint(&self) -> (uint, Option<uint>) { self.range.size_hint() }
 }
 
-impl<'a, 'b> DoubleEndedIterator<Commit<'a>> for Parents<'b, 'a> {
-    fn next_back(&mut self) -> Option<Commit<'a>> {
+impl<'repo, 'commit> DoubleEndedIterator<Commit<'repo>> for Parents<'commit, 'repo> {
+    fn next_back(&mut self) -> Option<Commit<'repo>> {
         self.range.next_back().map(|i| self.commit.parent(i).unwrap())
     }
 }
 
-impl<'a, 'b> ExactSizeIterator<Commit<'a>> for Parents<'b, 'a> {}
+impl<'repo, 'commit> ExactSizeIterator<Commit<'repo>> for Parents<'commit, 'repo> {}
 
-impl<'a> Iterator<Oid> for ParentIds<'a> {
+impl<'commit> Iterator<Oid> for ParentIds<'commit> {
     fn next(&mut self) -> Option<Oid> {
         self.range.next().map(|i| self.commit.parent_id(i).unwrap())
     }
     fn size_hint(&self) -> (uint, Option<uint>) { self.range.size_hint() }
 }
 
-impl<'a> DoubleEndedIterator<Oid> for ParentIds<'a> {
+impl<'commit> DoubleEndedIterator<Oid> for ParentIds<'commit> {
     fn next_back(&mut self) -> Option<Oid> {
         self.range.next_back().map(|i| self.commit.parent_id(i).unwrap())
     }
 }
 
-impl<'a> ExactSizeIterator<Oid> for ParentIds<'a> {}
+impl<'commit> ExactSizeIterator<Oid> for ParentIds<'commit> {}
 
 #[unsafe_destructor]
-impl<'a> Drop for Commit<'a> {
+impl<'repo> Drop for Commit<'repo> {
     fn drop(&mut self) {
         unsafe { raw::git_commit_free(self.raw) }
     }

src/config.rs

@@ -13,18 +13,19 @@ pub struct Config {
 /// A struct representing a certain entry owned by a `Config` instance.
 ///
 /// An entry has a name, a value, and a level it applies to.
-pub struct ConfigEntry<'a> {
+pub struct ConfigEntry<'cfg> {
     raw: *const raw::git_config_entry,
-    marker1: marker::ContravariantLifetime<'a>,
+    marker1: marker::ContravariantLifetime<'cfg>,
     marker2: marker::NoSend,
     marker3: marker::NoSync,
 }
 
 /// An iterator over the `ConfigEntry` values of a `Config` structure.
-pub struct ConfigEntries<'a> {
+pub struct ConfigEntries<'cfg> {
     raw: *mut raw::git_config_iterator,
-    _config: &'a Config,
-    marker: marker::NoSync,
+    marker1: marker::ContravariantLifetime<'cfg>,
+    marker2: marker::NoSend,
+    marker3: marker::NoSync,
 }
 
 impl Config {
@@ -187,7 +188,7 @@ impl Config {
     ///
     /// This is the same as `get_bytes` except that it may return `Err` if
     /// the bytes are not valid utf-8.
-    pub fn get_str<'a>(&self, name: &str) -> Result<&str, Error> {
+    pub fn get_str(&self, name: &str) -> Result<&str, Error> {
         str::from_utf8(try!(self.get_bytes(name))).map_err(|_| {
             Error::from_str("configuration value is not valid utf8")
         })
@@ -209,7 +210,7 @@ impl Config {
         unsafe {
             try_call!(raw::git_config_get_entry(&mut ret, &*self.raw,
                                                 name.to_c_str()));
-            Ok(ConfigEntry::from_raw(self, ret))
+            Ok(ConfigEntry::from_raw(ret))
         }
     }
 
@@ -242,7 +243,7 @@ impl Config {
                     try_call!(raw::git_config_iterator_new(&mut ret, &*self.raw));
                 }
             }
-            Ok(ConfigEntries::from_raw(self, ret))
+            Ok(ConfigEntries::from_raw(ret))
         }
     }
 
@@ -332,12 +333,12 @@ impl Drop for Config {
     }
 }
 
-impl<'a> ConfigEntry<'a> {
+impl<'cfg> ConfigEntry<'cfg> {
     /// Creates a new config entry from the raw components.
     ///
     /// This method is unsafe as the validity of `raw` is not guaranteed.
-    pub unsafe fn from_raw(_config: &Config, raw: *const raw::git_config_entry)
-                           -> ConfigEntry {
+    pub unsafe fn from_raw(raw: *const raw::git_config_entry)
+                           -> ConfigEntry<'cfg> {
         ConfigEntry {
             raw: raw,
             marker1: marker::ContravariantLifetime,
@@ -372,13 +373,18 @@ impl<'a> ConfigEntry<'a> {
     }
 }
 
-impl<'a> ConfigEntries<'a> {
+impl<'cfg> ConfigEntries<'cfg> {
     /// Creates a new iterator from its raw component.
     ///
     /// This function is unsafe as the validity of `raw` is not guaranteed.
-    pub unsafe fn from_raw(config: &Config, raw: *mut raw::git_config_iterator)
-                           -> ConfigEntries {
-        ConfigEntries { raw: raw, _config: config, marker: marker::NoSync }
+    pub unsafe fn from_raw(raw: *mut raw::git_config_iterator)
+                           -> ConfigEntries<'cfg> {
+        ConfigEntries {
+            raw: raw,
+            marker1: marker::ContravariantLifetime,
+            marker2: marker::NoSend,
+            marker3: marker::NoSync,
+        }
     }
 }
 
@@ -387,17 +393,12 @@ impl<'a> ConfigEntries<'a> {
 //
 // It's also not implemented for `&'b mut T` so we can have multiple entries
 // (ok).
-impl<'a, 'b> Iterator<ConfigEntry<'b>> for &'b ConfigEntries<'a> {
+impl<'cfg, 'b> Iterator<ConfigEntry<'b>> for &'b ConfigEntries<'cfg> {
     fn next(&mut self) -> Option<ConfigEntry<'b>> {
         let mut raw = 0 as *mut raw::git_config_entry;
         unsafe {
             if raw::git_config_next(&mut raw, self.raw) == 0 {
-                Some(ConfigEntry {
-                    raw: raw as *const raw::git_config_entry,
-                    marker1: marker::ContravariantLifetime,
-                    marker2: marker::NoSend,
-                    marker3: marker::NoSync,
-                })
+                Some(ConfigEntry::from_raw(raw))
             } else {
                 None
             }
@@ -406,7 +407,7 @@ impl<'a, 'b> Iterator<ConfigEntry<'b>> for &'b ConfigEntries<'a> {
 }
 
 #[unsafe_destructor]
-impl<'a> Drop for ConfigEntries<'a> {
+impl<'cfg> Drop for ConfigEntries<'cfg> {
     fn drop(&mut self) {
         unsafe { raw::git_config_iterator_free(self.raw) }
     }