libgit2.patch

   1 diff -urN rustc-1.56.0-src/Cargo.lock rustc-1.56.0-src-git2/Cargo.lock
   2 --- rustc-1.56.0-src/Cargo.lock 2021-10-18 11:52:36.000000000 +0200
   3 +++ rustc-1.56.0-src-git2/Cargo.lock    2021-10-23 20:59:08.434911180 +0200
   4 @@ -1429,7 +1429,7 @@
   5
   6  [[package]]
   7  name = "git2"
   8 -version = "0.13.17"
   9 +version = "0.13.23"
  10  source = "registry+https://github.com/rust-lang/crates.io-index"
  11  checksum = "1d250f5f82326884bd39c2853577e70a121775db76818ffa452ed1e80de12986"
  12  dependencies = [
  13 @@ -1889,7 +1889,7 @@
  14
  15  [[package]]
  16  name = "libgit2-sys"
  17 -version = "0.12.18+1.1.0"
  18 +version = "0.12.24+1.3.0"
  19  source = "registry+https://github.com/rust-lang/crates.io-index"
  20  checksum = "3da6a42da88fc37ee1ecda212ffa254c25713532980005d5f7c0b0fbe7e6e885"
  21  dependencies = [
  22 diff -urN rustc-1.56.0-src/src/tools/cargo/Cargo.toml rustc-1.56.0-src-git2/src/tools/cargo/Cargo.toml
  23 --- rustc-1.56.0-src/src/tools/cargo/Cargo.toml 2021-10-18 11:52:56.000000000 +0200
  24 +++ rustc-1.56.0-src-git2/src/tools/cargo/Cargo.toml    2021-10-23 21:00:31.124770799 +0200
  25 @@ -44,7 +44,7 @@
  26  lazycell = "1.2.0"
  27  libc = "0.2"
  28  log = "0.4.6"
  29 -libgit2-sys = "0.12.18"
  30 +libgit2-sys = "0.12.24"
  31  memchr = "2.1.3"
  32  num_cpus = "1.0"
  33  opener = "0.5"
  34 diff -urN rustc-1.56.0-src/src/tools/miri/cargo-miri/Cargo.lock rustc-1.56.0-src-git2/src/tools/miri/cargo-miri/Cargo.lock
  35 --- rustc-1.56.0-src/src/tools/miri/cargo-miri/Cargo.lock       2021-10-18 11:52:56.000000000 +0200
  36 +++ rustc-1.56.0-src-git2/src/tools/miri/cargo-miri/Cargo.lock  2021-10-23 21:01:01.564718045 +0200
  37 @@ -181,7 +181,7 @@
  38
  39  [[package]]
  40  name = "git2"
  41 -version = "0.13.17"
  42 +version = "0.13.23"
  43  source = "registry+https://github.com/rust-lang/crates.io-index"
  44  checksum = "1d250f5f82326884bd39c2853577e70a121775db76818ffa452ed1e80de12986"
  45  dependencies = [
  46 @@ -232,7 +232,7 @@
  47
  48  [[package]]
  49  name = "libgit2-sys"
  50 -version = "0.12.18+1.1.0"
  51 +version = "0.12.24+1.3.0"
  52  source = "registry+https://github.com/rust-lang/crates.io-index"
  53  checksum = "3da6a42da88fc37ee1ecda212ffa254c25713532980005d5f7c0b0fbe7e6e885"
  54  dependencies = [
  55 diff -urN rustc-1.56.0-src/src/tools/rls/Cargo.lock rustc-1.56.0-src-git2/src/tools/rls/Cargo.lock
  56 --- rustc-1.56.0-src/src/tools/rls/Cargo.lock   2021-10-18 11:52:56.000000000 +0200
  57 +++ rustc-1.56.0-src-git2/src/tools/rls/Cargo.lock      2021-10-23 20:55:59.835212449 +0200
  58 @@ -854,7 +854,7 @@
  59
  60  [[package]]
  61  name = "git2"
  62 -version = "0.13.17"
  63 +version = "0.13.23"
  64  source = "registry+https://github.com/rust-lang/crates.io-index"
  65  checksum = "1d250f5f82326884bd39c2853577e70a121775db76818ffa452ed1e80de12986"
  66  dependencies = [
  67 @@ -1216,7 +1216,7 @@
  68
  69  [[package]]
  70  name = "libgit2-sys"
  71 -version = "0.12.18+1.1.0"
  72 +version = "0.12.24+1.3.0"
  73  source = "registry+https://github.com/rust-lang/crates.io-index"
  74  checksum = "3da6a42da88fc37ee1ecda212ffa254c25713532980005d5f7c0b0fbe7e6e885"
  75  dependencies = [
  76 diff -urN rustc-1.56.0-src/vendor/git2/Cargo.lock rustc-1.56.0-src-git2/vendor/git2/Cargo.lock
  77 --- rustc-1.56.0-src/vendor/git2/Cargo.lock     2021-10-18 13:05:54.000000000 +0200
  78 +++ rustc-1.56.0-src-git2/vendor/git2/Cargo.lock        2021-10-23 20:59:46.411513930 +0200
  79 @@ -94,7 +94,7 @@
  80
  81  [[package]]
  82  name = "git2"
  83 -version = "0.13.17"
  84 +version = "0.13.23"
  85  dependencies = [
  86   "bitflags",
  87   "libc",
  88 @@ -162,7 +162,7 @@
  89
  90  [[package]]
  91  name = "libgit2-sys"
  92 -version = "0.12.18+1.1.0"
  93 +version = "0.12.24+1.3.0"
  94  source = "registry+https://github.com/rust-lang/crates.io-index"
  95  checksum = "3da6a42da88fc37ee1ecda212ffa254c25713532980005d5f7c0b0fbe7e6e885"
  96  dependencies = [
  97 diff -urN rustc-1.56.0-src/vendor/git2/Cargo.toml rustc-1.56.0-src-git2/vendor/git2/Cargo.toml
  98 --- rustc-1.56.0-src/vendor/git2/Cargo.toml     2021-10-18 13:05:54.000000000 +0200
  99 +++ rustc-1.56.0-src-git2/vendor/git2/Cargo.toml        2021-10-23 20:47:39.252455615 +0200
 100 @@ -13,7 +13,7 @@
 101  [package]
 102  edition = "2018"
 103  name = "git2"
 104 -version = "0.13.17"
 105 +version = "0.13.23"
 106  authors = ["Josh Triplett <josh@joshtriplett.org>", "Alex Crichton <alex@alexcrichton.com>"]
 107  description = "Bindings to libgit2 for interoperating with git repositories. This library is\nboth threadsafe and memory safe and allows both reading and writing git\nrepositories.\n"
 108  documentation = "https://docs.rs/git2"
 109 @@ -29,7 +29,7 @@
 110  version = "0.2"
 111
 112  [dependencies.libgit2-sys]
 113 -version = "0.12.18"
 114 +version = "0.12.24"
 115
 116  [dependencies.log]
 117  version = "0.4.8"
 118 diff -urN rustc-1.56.0-src/vendor/git2/README.md rustc-1.56.0-src-git2/vendor/git2/README.md
 119 --- rustc-1.56.0-src/vendor/git2/README.md      2021-10-18 13:05:54.000000000 +0200
 120 +++ rustc-1.56.0-src-git2/vendor/git2/README.md 2021-10-23 20:47:39.252455615 +0200
 121 @@ -12,8 +12,7 @@
 122  ## Rust version requirements
 123
 124  git2-rs works with stable Rust, and typically works with the most recent prior
 125 -stable release as well. Check the MSRV job of [the CI script](.github/workflows/main.yml) to see the oldest
 126 -version of Rust known to pass tests.
 127 +stable release as well.
 128
 129  ## Version of libgit2
 130
 131 diff -urN rustc-1.56.0-src/vendor/git2/src/attr.rs rustc-1.56.0-src-git2/vendor/git2/src/attr.rs
 132 --- rustc-1.56.0-src/vendor/git2/src/attr.rs    1970-01-01 01:00:00.000000000 +0100
 133 +++ rustc-1.56.0-src-git2/vendor/git2/src/attr.rs       2021-10-23 20:47:39.252455615 +0200
 134 @@ -0,0 +1,175 @@
 135 +use crate::raw;
 136 +use std::ptr;
 137 +use std::str;
 138 +
 139 +/// All possible states of an attribute.
 140 +///
 141 +/// This enum is used to interpret the value returned by
 142 +/// [`Repository::get_attr`](crate::Repository::get_attr) and
 143 +/// [`Repository::get_attr_bytes`](crate::Repository::get_attr_bytes).
 144 +#[derive(Debug, Clone, Copy, Eq)]
 145 +pub enum AttrValue<'string> {
 146 +    /// The attribute is set to true.
 147 +    True,
 148 +    /// The attribute is unset (set to false).
 149 +    False,
 150 +    /// The attribute is set to a [valid UTF-8 string](prim@str).
 151 +    String(&'string str),
 152 +    /// The attribute is set to a string that might not be [valid UTF-8](prim@str).
 153 +    Bytes(&'string [u8]),
 154 +    /// The attribute is not specified.
 155 +    Unspecified,
 156 +}
 157 +
 158 +macro_rules! from_value {
 159 +    ($value:expr => $string:expr) => {
 160 +        match unsafe { raw::git_attr_value($value.map_or(ptr::null(), |v| v.as_ptr().cast())) } {
 161 +            raw::GIT_ATTR_VALUE_TRUE => Self::True,
 162 +            raw::GIT_ATTR_VALUE_FALSE => Self::False,
 163 +            raw::GIT_ATTR_VALUE_STRING => $string,
 164 +            raw::GIT_ATTR_VALUE_UNSPECIFIED => Self::Unspecified,
 165 +            _ => unreachable!(),
 166 +        }
 167 +    };
 168 +}
 169 +
 170 +impl<'string> AttrValue<'string> {
 171 +    /// Returns the state of an attribute by inspecting its [value](crate::Repository::get_attr)
 172 +    /// by a [string](prim@str).
 173 +    ///
 174 +    /// This function always returns [`AttrValue::String`] and never returns [`AttrValue::Bytes`]
 175 +    /// when the attribute is set to a string.
 176 +    pub fn from_string(value: Option<&'string str>) -> Self {
 177 +        from_value!(value => Self::String(value.unwrap()))
 178 +    }
 179 +
 180 +    /// Returns the state of an attribute by inspecting its [value](crate::Repository::get_attr_bytes)
 181 +    /// by a [byte](u8) [slice].
 182 +    ///
 183 +    /// This function will perform UTF-8 validation when the attribute is set to a string, returns
 184 +    /// [`AttrValue::String`] if it's valid UTF-8 and [`AttrValue::Bytes`] otherwise.
 185 +    pub fn from_bytes(value: Option<&'string [u8]>) -> Self {
 186 +        let mut value = Self::always_bytes(value);
 187 +        if let Self::Bytes(bytes) = value {
 188 +            if let Ok(string) = str::from_utf8(bytes) {
 189 +                value = Self::String(string);
 190 +            }
 191 +        }
 192 +        value
 193 +    }
 194 +
 195 +    /// Returns the state of an attribute just like [`AttrValue::from_bytes`], but skips UTF-8
 196 +    /// validation and always returns [`AttrValue::Bytes`] when it's set to a string.
 197 +    pub fn always_bytes(value: Option<&'string [u8]>) -> Self {
 198 +        from_value!(value => Self::Bytes(value.unwrap()))
 199 +    }
 200 +}
 201 +
 202 +/// Compare two [`AttrValue`]s.
 203 +///
 204 +/// Note that this implementation does not differentiate between [`AttrValue::String`] and
 205 +/// [`AttrValue::Bytes`].
 206 +impl PartialEq for AttrValue<'_> {
 207 +    fn eq(&self, other: &AttrValue<'_>) -> bool {
 208 +        match (self, other) {
 209 +            (Self::True, AttrValue::True)
 210 +            | (Self::False, AttrValue::False)
 211 +            | (Self::Unspecified, AttrValue::Unspecified) => true,
 212 +            (AttrValue::String(string), AttrValue::Bytes(bytes))
 213 +            | (AttrValue::Bytes(bytes), AttrValue::String(string)) => string.as_bytes() == *bytes,
 214 +            (AttrValue::String(left), AttrValue::String(right)) => left == right,
 215 +            (AttrValue::Bytes(left), AttrValue::Bytes(right)) => left == right,
 216 +            _ => false,
 217 +        }
 218 +    }
 219 +}
 220 +
 221 +#[cfg(test)]
 222 +mod tests {
 223 +    use super::AttrValue;
 224 +
 225 +    macro_rules! test_attr_value {
 226 +        ($function:ident, $variant:ident) => {
 227 +            const ATTR_TRUE: &str = "[internal]__TRUE__";
 228 +            const ATTR_FALSE: &str = "[internal]__FALSE__";
 229 +            const ATTR_UNSET: &str = "[internal]__UNSET__";
 230 +            let as_bytes = AsRef::<[u8]>::as_ref;
 231 +            // Use `matches!` here since the `PartialEq` implementation does not differentiate
 232 +            // between `String` and `Bytes`.
 233 +            assert!(matches!(
 234 +                AttrValue::$function(Some(ATTR_TRUE.as_ref())),
 235 +                AttrValue::$variant(s) if as_bytes(s) == ATTR_TRUE.as_bytes()
 236 +            ));
 237 +            assert!(matches!(
 238 +                AttrValue::$function(Some(ATTR_FALSE.as_ref())),
 239 +                AttrValue::$variant(s) if as_bytes(s) == ATTR_FALSE.as_bytes()
 240 +            ));
 241 +            assert!(matches!(
 242 +                AttrValue::$function(Some(ATTR_UNSET.as_ref())),
 243 +                AttrValue::$variant(s) if as_bytes(s) == ATTR_UNSET.as_bytes()
 244 +            ));
 245 +            assert!(matches!(
 246 +                AttrValue::$function(Some("foo".as_ref())),
 247 +                AttrValue::$variant(s) if as_bytes(s) == b"foo"
 248 +            ));
 249 +            assert!(matches!(
 250 +                AttrValue::$function(Some("bar".as_ref())),
 251 +                AttrValue::$variant(s) if as_bytes(s) == b"bar"
 252 +            ));
 253 +            assert_eq!(AttrValue::$function(None), AttrValue::Unspecified);
 254 +        };
 255 +    }
 256 +
 257 +    #[test]
 258 +    fn attr_value_from_string() {
 259 +        test_attr_value!(from_string, String);
 260 +    }
 261 +
 262 +    #[test]
 263 +    fn attr_value_from_bytes() {
 264 +        test_attr_value!(from_bytes, String);
 265 +        assert!(matches!(
 266 +            AttrValue::from_bytes(Some(&[0xff])),
 267 +            AttrValue::Bytes(&[0xff])
 268 +        ));
 269 +        assert!(matches!(
 270 +            AttrValue::from_bytes(Some(b"\xffoobar")),
 271 +            AttrValue::Bytes(b"\xffoobar")
 272 +        ));
 273 +    }
 274 +
 275 +    #[test]
 276 +    fn attr_value_always_bytes() {
 277 +        test_attr_value!(always_bytes, Bytes);
 278 +        assert!(matches!(
 279 +            AttrValue::always_bytes(Some(&[0xff; 2])),
 280 +            AttrValue::Bytes(&[0xff, 0xff])
 281 +        ));
 282 +        assert!(matches!(
 283 +            AttrValue::always_bytes(Some(b"\xffoo")),
 284 +            AttrValue::Bytes(b"\xffoo")
 285 +        ));
 286 +    }
 287 +
 288 +    #[test]
 289 +    fn attr_value_partial_eq() {
 290 +        assert_eq!(AttrValue::True, AttrValue::True);
 291 +        assert_eq!(AttrValue::False, AttrValue::False);
 292 +        assert_eq!(AttrValue::String("foo"), AttrValue::String("foo"));
 293 +        assert_eq!(AttrValue::Bytes(b"foo"), AttrValue::Bytes(b"foo"));
 294 +        assert_eq!(AttrValue::String("bar"), AttrValue::Bytes(b"bar"));
 295 +        assert_eq!(AttrValue::Bytes(b"bar"), AttrValue::String("bar"));
 296 +        assert_eq!(AttrValue::Unspecified, AttrValue::Unspecified);
 297 +        assert_ne!(AttrValue::True, AttrValue::False);
 298 +        assert_ne!(AttrValue::False, AttrValue::Unspecified);
 299 +        assert_ne!(AttrValue::Unspecified, AttrValue::True);
 300 +        assert_ne!(AttrValue::True, AttrValue::String("true"));
 301 +        assert_ne!(AttrValue::Unspecified, AttrValue::Bytes(b"unspecified"));
 302 +        assert_ne!(AttrValue::Bytes(b"false"), AttrValue::False);
 303 +        assert_ne!(AttrValue::String("unspecified"), AttrValue::Unspecified);
 304 +        assert_ne!(AttrValue::String("foo"), AttrValue::String("bar"));
 305 +        assert_ne!(AttrValue::Bytes(b"foo"), AttrValue::Bytes(b"bar"));
 306 +        assert_ne!(AttrValue::String("foo"), AttrValue::Bytes(b"bar"));
 307 +        assert_ne!(AttrValue::Bytes(b"foo"), AttrValue::String("bar"));
 308 +    }
 309 +}
 310 diff -urN rustc-1.56.0-src/vendor/git2/src/blame.rs rustc-1.56.0-src-git2/vendor/git2/src/blame.rs
 311 --- rustc-1.56.0-src/vendor/git2/src/blame.rs   2021-10-18 13:05:54.000000000 +0200
 312 +++ rustc-1.56.0-src-git2/vendor/git2/src/blame.rs      2021-10-23 20:47:39.252455615 +0200
 313 @@ -228,6 +228,18 @@
 314          }
 315          self
 316      }
 317 +
 318 +    /// The first line in the file to blame.
 319 +    pub fn min_line(&mut self, lineno: usize) -> &mut BlameOptions {
 320 +        self.raw.min_line = lineno;
 321 +        self
 322 +    }
 323 +
 324 +    /// The last line in the file to blame.
 325 +    pub fn max_line(&mut self, lineno: usize) -> &mut BlameOptions {
 326 +        self.raw.max_line = lineno;
 327 +        self
 328 +    }
 329  }
 330
 331  impl<'repo> Binding for Blame<'repo> {
 332 @@ -235,7 +247,7 @@
 333
 334      unsafe fn from_raw(raw: *mut raw::git_blame) -> Blame<'repo> {
 335          Blame {
 336 -            raw: raw,
 337 +            raw,
 338              _marker: marker::PhantomData,
 339          }
 340      }
 341 @@ -256,7 +268,7 @@
 342
 343      unsafe fn from_raw(raw: *mut raw::git_blame_hunk) -> BlameHunk<'blame> {
 344          BlameHunk {
 345 -            raw: raw,
 346 +            raw,
 347              _marker: marker::PhantomData,
 348          }
 349      }
 350 diff -urN rustc-1.56.0-src/vendor/git2/src/blob.rs rustc-1.56.0-src-git2/vendor/git2/src/blob.rs
 351 --- rustc-1.56.0-src/vendor/git2/src/blob.rs    2021-10-18 13:05:54.000000000 +0200
 352 +++ rustc-1.56.0-src-git2/vendor/git2/src/blob.rs       2021-10-23 20:47:39.252455615 +0200
 353 @@ -56,7 +56,7 @@
 354
 355      unsafe fn from_raw(raw: *mut raw::git_blob) -> Blob<'repo> {
 356          Blob {
 357 -            raw: raw,
 358 +            raw,
 359              _marker: marker::PhantomData,
 360          }
 361      }
 362 @@ -110,7 +110,7 @@
 363
 364      unsafe fn from_raw(raw: *mut raw::git_writestream) -> BlobWriter<'repo> {
 365          BlobWriter {
 366 -            raw: raw,
 367 +            raw,
 368              need_cleanup: true,
 369              _marker: marker::PhantomData,
 370          }
 371 diff -urN rustc-1.56.0-src/vendor/git2/src/branch.rs rustc-1.56.0-src-git2/vendor/git2/src/branch.rs
 372 --- rustc-1.56.0-src/vendor/git2/src/branch.rs  2021-10-18 13:05:54.000000000 +0200
 373 +++ rustc-1.56.0-src-git2/vendor/git2/src/branch.rs     2021-10-23 20:47:39.252455615 +0200
 374 @@ -28,6 +28,17 @@
 375          Branch { inner: reference }
 376      }
 377
 378 +    /// Ensure the branch name is well-formed.
 379 +    pub fn name_is_valid(name: &str) -> Result<bool, Error> {
 380 +        crate::init();
 381 +        let name = CString::new(name)?;
 382 +        let mut valid: libc::c_int = 0;
 383 +        unsafe {
 384 +            try_call!(raw::git_branch_name_is_valid(&mut valid, name.as_ptr()));
 385 +        }
 386 +        Ok(valid == 1)
 387 +    }
 388 +
 389      /// Gain access to the reference that is this branch
 390      pub fn get(&self) -> &Reference<'repo> {
 391          &self.inner
 392 @@ -120,7 +131,7 @@
 393      /// pointer.
 394      pub unsafe fn from_raw(raw: *mut raw::git_branch_iterator) -> Branches<'repo> {
 395          Branches {
 396 -            raw: raw,
 397 +            raw,
 398              _marker: marker::PhantomData,
 399          }
 400      }
 401 @@ -151,7 +162,7 @@
 402
 403  #[cfg(test)]
 404  mod tests {
 405 -    use crate::BranchType;
 406 +    use crate::{Branch, BranchType};
 407
 408      #[test]
 409      fn smoke() {
 410 @@ -175,4 +186,12 @@
 411
 412          b1.delete().unwrap();
 413      }
 414 +
 415 +    #[test]
 416 +    fn name_is_valid() {
 417 +        assert!(Branch::name_is_valid("foo").unwrap());
 418 +        assert!(!Branch::name_is_valid("").unwrap());
 419 +        assert!(!Branch::name_is_valid("with spaces").unwrap());
 420 +        assert!(!Branch::name_is_valid("~tilde").unwrap());
 421 +    }
 422  }
 423 diff -urN rustc-1.56.0-src/vendor/git2/src/call.rs rustc-1.56.0-src-git2/vendor/git2/src/call.rs
 424 --- rustc-1.56.0-src/vendor/git2/src/call.rs    2021-10-18 13:05:54.000000000 +0200
 425 +++ rustc-1.56.0-src-git2/vendor/git2/src/call.rs       2021-10-23 20:47:39.252455615 +0200
 426 @@ -58,7 +58,9 @@
 427
 428      use crate::call::Convert;
 429      use crate::{raw, BranchType, ConfigLevel, Direction, ObjectType, ResetType};
 430 -    use crate::{AutotagOption, DiffFormat, FetchPrune, FileFavor, SubmoduleIgnore};
 431 +    use crate::{
 432 +        AutotagOption, DiffFormat, FetchPrune, FileFavor, SubmoduleIgnore, SubmoduleUpdate,
 433 +    };
 434
 435      impl<T: Copy> Convert<T> for T {
 436          fn convert(&self) -> T {
 437 @@ -208,6 +210,18 @@
 438              }
 439          }
 440      }
 441 +
 442 +    impl Convert<raw::git_submodule_update_t> for SubmoduleUpdate {
 443 +        fn convert(&self) -> raw::git_submodule_update_t {
 444 +            match *self {
 445 +                SubmoduleUpdate::Checkout => raw::GIT_SUBMODULE_UPDATE_CHECKOUT,
 446 +                SubmoduleUpdate::Rebase => raw::GIT_SUBMODULE_UPDATE_REBASE,
 447 +                SubmoduleUpdate::Merge => raw::GIT_SUBMODULE_UPDATE_MERGE,
 448 +                SubmoduleUpdate::None => raw::GIT_SUBMODULE_UPDATE_NONE,
 449 +                SubmoduleUpdate::Default => raw::GIT_SUBMODULE_UPDATE_DEFAULT,
 450 +            }
 451 +        }
 452 +    }
 453
 454      impl Convert<raw::git_remote_autotag_option_t> for AutotagOption {
 455          fn convert(&self) -> raw::git_remote_autotag_option_t {
 456 diff -urN rustc-1.56.0-src/vendor/git2/src/cert.rs rustc-1.56.0-src-git2/vendor/git2/src/cert.rs
 457 --- rustc-1.56.0-src/vendor/git2/src/cert.rs    2021-10-18 13:05:54.000000000 +0200
 458 +++ rustc-1.56.0-src-git2/vendor/git2/src/cert.rs       2021-10-23 20:47:39.252455615 +0200
 459 @@ -100,7 +100,7 @@
 460      type Raw = *mut raw::git_cert;
 461      unsafe fn from_raw(raw: *mut raw::git_cert) -> Cert<'a> {
 462          Cert {
 463 -            raw: raw,
 464 +            raw,
 465              _marker: marker::PhantomData,
 466          }
 467      }
 468 diff -urN rustc-1.56.0-src/vendor/git2/src/commit.rs rustc-1.56.0-src-git2/vendor/git2/src/commit.rs
 469 --- rustc-1.56.0-src/vendor/git2/src/commit.rs  2021-10-18 13:05:54.000000000 +0200
 470 +++ rustc-1.56.0-src-git2/vendor/git2/src/commit.rs     2021-10-23 20:47:39.252455615 +0200
 471 @@ -6,7 +6,7 @@
 472  use std::str;
 473
 474  use crate::util::Binding;
 475 -use crate::{raw, signature, Error, Object, Oid, Signature, Time, Tree};
 476 +use crate::{raw, signature, Buf, Error, IntoCString, Mailmap, Object, Oid, Signature, Time, Tree};
 477
 478  /// A structure to represent a git [commit][1]
 479  ///
 480 @@ -105,6 +105,20 @@
 481          str::from_utf8(self.raw_header_bytes()).ok()
 482      }
 483
 484 +    /// Get an arbitrary header field.
 485 +    pub fn header_field_bytes<T: IntoCString>(&self, field: T) -> Result<Buf, Error> {
 486 +        let buf = Buf::new();
 487 +        let raw_field = field.into_c_string()?;
 488 +        unsafe {
 489 +            try_call!(raw::git_commit_header_field(
 490 +                buf.raw(),
 491 +                &*self.raw,
 492 +                raw_field
 493 +            ));
 494 +        }
 495 +        Ok(buf)
 496 +    }
 497 +
 498      /// Get the full raw text of the commit header.
 499      pub fn raw_header_bytes(&self) -> &[u8] {
 500          unsafe { crate::opt_bytes(self, raw::git_commit_raw_header(&*self.raw)).unwrap() }
 501 @@ -169,6 +183,20 @@
 502          }
 503      }
 504
 505 +    /// Get the author of this commit, using the mailmap to map names and email
 506 +    /// addresses to canonical real names and email addresses.
 507 +    pub fn author_with_mailmap(&self, mailmap: &Mailmap) -> Result<Signature<'static>, Error> {
 508 +        let mut ret = ptr::null_mut();
 509 +        unsafe {
 510 +            try_call!(raw::git_commit_author_with_mailmap(
 511 +                &mut ret,
 512 +                &*self.raw,
 513 +                &*mailmap.raw()
 514 +            ));
 515 +            Ok(Binding::from_raw(ret))
 516 +        }
 517 +    }
 518 +
 519      /// Get the committer of this commit.
 520      pub fn committer(&self) -> Signature<'_> {
 521          unsafe {
 522 @@ -177,6 +205,20 @@
 523          }
 524      }
 525
 526 +    /// Get the committer of this commit, using the mailmap to map names and email
 527 +    /// addresses to canonical real names and email addresses.
 528 +    pub fn committer_with_mailmap(&self, mailmap: &Mailmap) -> Result<Signature<'static>, Error> {
 529 +        let mut ret = ptr::null_mut();
 530 +        unsafe {
 531 +            try_call!(raw::git_commit_committer_with_mailmap(
 532 +                &mut ret,
 533 +                &*self.raw,
 534 +                &*mailmap.raw()
 535 +            ));
 536 +            Ok(Binding::from_raw(ret))
 537 +        }
 538 +    }
 539 +
 540      /// Amend this existing commit with all non-`None` values
 541      ///
 542      /// This creates a new commit that is exactly the same as the old commit,
 543 @@ -271,7 +313,7 @@
 544      type Raw = *mut raw::git_commit;
 545      unsafe fn from_raw(raw: *mut raw::git_commit) -> Commit<'repo> {
 546          Commit {
 547 -            raw: raw,
 548 +            raw,
 549              _marker: marker::PhantomData,
 550          }
 551      }
 552 @@ -367,6 +409,11 @@
 553          commit.tree().unwrap();
 554          assert_eq!(commit.parents().count(), 0);
 555
 556 +        let tree_header_bytes = commit.header_field_bytes("tree").unwrap();
 557 +        assert_eq!(
 558 +            crate::Oid::from_str(tree_header_bytes.as_str().unwrap()).unwrap(),
 559 +            commit.tree_id()
 560 +        );
 561          assert_eq!(commit.author().name(), Some("name"));
 562          assert_eq!(commit.author().email(), Some("email"));
 563          assert_eq!(commit.committer().name(), Some("name"));
 564 diff -urN rustc-1.56.0-src/vendor/git2/src/config.rs rustc-1.56.0-src-git2/vendor/git2/src/config.rs
 565 --- rustc-1.56.0-src/vendor/git2/src/config.rs  2021-10-18 13:05:54.000000000 +0200
 566 +++ rustc-1.56.0-src-git2/vendor/git2/src/config.rs     2021-10-23 20:47:39.252455615 +0200
 567 @@ -465,7 +465,7 @@
 568  impl Binding for Config {
 569      type Raw = *mut raw::git_config;
 570      unsafe fn from_raw(raw: *mut raw::git_config) -> Config {
 571 -        Config { raw: raw }
 572 +        Config { raw }
 573      }
 574      fn raw(&self) -> *mut raw::git_config {
 575          self.raw
 576 @@ -534,7 +534,7 @@
 577
 578      unsafe fn from_raw(raw: *mut raw::git_config_entry) -> ConfigEntry<'cfg> {
 579          ConfigEntry {
 580 -            raw: raw,
 581 +            raw,
 582              _marker: marker::PhantomData,
 583              owned: true,
 584          }
 585 @@ -549,7 +549,7 @@
 586
 587      unsafe fn from_raw(raw: *mut raw::git_config_iterator) -> ConfigEntries<'cfg> {
 588          ConfigEntries {
 589 -            raw: raw,
 590 +            raw,
 591              _marker: marker::PhantomData,
 592          }
 593      }
 594 @@ -571,7 +571,7 @@
 595              try_call_iter!(raw::git_config_next(&mut raw, self.raw));
 596              Some(Ok(ConfigEntry {
 597                  owned: false,
 598 -                raw: raw,
 599 +                raw,
 600                  _marker: marker::PhantomData,
 601              }))
 602          }
 603 diff -urN rustc-1.56.0-src/vendor/git2/src/cred.rs rustc-1.56.0-src-git2/vendor/git2/src/cred.rs
 604 --- rustc-1.56.0-src/vendor/git2/src/cred.rs    2021-10-18 13:05:54.000000000 +0200
 605 +++ rustc-1.56.0-src-git2/vendor/git2/src/cred.rs       2021-10-23 20:47:39.252455615 +0200
 606 @@ -22,6 +22,7 @@
 607      pub username: Option<String>,
 608      protocol: Option<String>,
 609      host: Option<String>,
 610 +    port: Option<u16>,
 611      path: Option<String>,
 612      url: String,
 613      commands: Vec<String>,
 614 @@ -170,7 +171,7 @@
 615      type Raw = *mut raw::git_cred;
 616
 617      unsafe fn from_raw(raw: *mut raw::git_cred) -> Cred {
 618 -        Cred { raw: raw }
 619 +        Cred { raw }
 620      }
 621      fn raw(&self) -> *mut raw::git_cred {
 622          self.raw
 623 @@ -199,6 +200,7 @@
 624          let mut ret = CredentialHelper {
 625              protocol: None,
 626              host: None,
 627 +            port: None,
 628              path: None,
 629              username: None,
 630              url: url.to_string(),
 631 @@ -210,6 +212,7 @@
 632              if let Some(url::Host::Domain(s)) = url.host() {
 633                  ret.host = Some(s.to_string());
 634              }
 635 +            ret.port = url.port();
 636              ret.protocol = Some(url.scheme().to_string());
 637          }
 638          ret
 639 @@ -408,7 +411,11 @@
 640                  let _ = writeln!(stdin, "protocol={}", p);
 641              }
 642              if let Some(ref p) = self.host {
 643 -                let _ = writeln!(stdin, "host={}", p);
 644 +                if let Some(ref p2) = self.port {
 645 +                    let _ = writeln!(stdin, "host={}:{}", p, p2);
 646 +                } else {
 647 +                    let _ = writeln!(stdin, "host={}", p);
 648 +                }
 649              }
 650              if let Some(ref p) = self.path {
 651                  let _ = writeln!(stdin, "path={}", p);
 652 @@ -640,6 +647,19 @@
 653      }
 654
 655      #[test]
 656 +    fn credential_helper9() {
 657 +        let cfg = test_cfg! {
 658 +            "credential.helper" => "!f() { while read line; do eval $line; done; if [ \"$host\" = example.com:3000 ]; then echo username=a; echo password=b; fi; }; f"
 659 +        };
 660 +        let (u, p) = CredentialHelper::new("https://example.com:3000/foo/bar")
 661 +            .config(&cfg)
 662 +            .execute()
 663 +            .unwrap();
 664 +        assert_eq!(u, "a");
 665 +        assert_eq!(p, "b");
 666 +    }
 667 +
 668 +    #[test]
 669      #[cfg(feature = "ssh")]
 670      fn ssh_key_from_memory() {
 671          let cred = Cred::ssh_key_from_memory(
 672 diff -urN rustc-1.56.0-src/vendor/git2/src/describe.rs rustc-1.56.0-src-git2/vendor/git2/src/describe.rs
 673 --- rustc-1.56.0-src/vendor/git2/src/describe.rs        2021-10-18 13:05:54.000000000 +0200
 674 +++ rustc-1.56.0-src-git2/vendor/git2/src/describe.rs   2021-10-23 20:47:39.255788944 +0200
 675 @@ -44,7 +44,7 @@
 676
 677      unsafe fn from_raw(raw: *mut raw::git_describe_result) -> Describe<'repo> {
 678          Describe {
 679 -            raw: raw,
 680 +            raw,
 681              _marker: marker::PhantomData,
 682          }
 683      }
 684 diff -urN rustc-1.56.0-src/vendor/git2/src/diff.rs rustc-1.56.0-src-git2/vendor/git2/src/diff.rs
 685 --- rustc-1.56.0-src/vendor/git2/src/diff.rs    2021-10-18 13:05:54.000000000 +0200
 686 +++ rustc-1.56.0-src-git2/vendor/git2/src/diff.rs       2021-10-23 20:47:39.255788944 +0200
 687 @@ -58,6 +58,11 @@
 688      raw: raw::git_diff_format_email_options,
 689  }
 690
 691 +/// Control behavior of formatting emails
 692 +pub struct DiffPatchidOptions {
 693 +    raw: raw::git_diff_patchid_options,
 694 +}
 695 +
 696  /// An iterator over the diffs in a delta
 697  pub struct Deltas<'diff> {
 698      range: Range<usize>,
 699 @@ -278,6 +283,21 @@
 700          Ok(buf)
 701      }
 702
 703 +    /// Create an patchid from a diff.
 704 +    pub fn patchid(&self, opts: Option<&mut DiffPatchidOptions>) -> Result<Oid, Error> {
 705 +        let mut raw = raw::git_oid {
 706 +            id: [0; raw::GIT_OID_RAWSZ],
 707 +        };
 708 +        unsafe {
 709 +            try_call!(raw::git_diff_patchid(
 710 +                &mut raw,
 711 +                self.raw,
 712 +                opts.map(|o| &mut o.raw)
 713 +            ));
 714 +            Ok(Binding::from_raw(&raw as *const _))
 715 +        }
 716 +    }
 717 +
 718      // TODO: num_deltas_of_type, find_similar
 719  }
 720  impl Diff<'static> {
 721 @@ -289,6 +309,7 @@
 722      /// a patch file likely contains abbreviated object IDs, so the
 723      /// object IDs parsed by this function will also be abreviated.
 724      pub fn from_buffer(buffer: &[u8]) -> Result<Diff<'static>, Error> {
 725 +        crate::init();
 726          let mut diff: *mut raw::git_diff = std::ptr::null_mut();
 727          unsafe {
 728              // NOTE: Doesn't depend on repo, so lifetime can be 'static
 729 @@ -318,9 +339,9 @@
 730              (*data)(delta, hunk, line)
 731          });
 732          if r == Some(true) {
 733 -            0
 734 +            raw::GIT_OK
 735          } else {
 736 -            -1
 737 +            raw::GIT_EUSER
 738          }
 739      }
 740  }
 741 @@ -341,9 +362,9 @@
 742              }
 743          });
 744          if r == Some(true) {
 745 -            0
 746 +            raw::GIT_OK
 747          } else {
 748 -            -1
 749 +            raw::GIT_EUSER
 750          }
 751      }
 752  }
 753 @@ -365,9 +386,9 @@
 754              }
 755          });
 756          if r == Some(true) {
 757 -            0
 758 +            raw::GIT_OK
 759          } else {
 760 -            -1
 761 +            raw::GIT_EUSER
 762          }
 763      }
 764  }
 765 @@ -389,9 +410,9 @@
 766              }
 767          });
 768          if r == Some(true) {
 769 -            0
 770 +            raw::GIT_OK
 771          } else {
 772 -            -1
 773 +            raw::GIT_EUSER
 774          }
 775      }
 776  }
 777 @@ -415,9 +436,9 @@
 778              }
 779          });
 780          if r == Some(true) {
 781 -            0
 782 +            raw::GIT_OK
 783          } else {
 784 -            -1
 785 +            raw::GIT_EUSER
 786          }
 787      }
 788  }
 789 @@ -426,7 +447,7 @@
 790      type Raw = *mut raw::git_diff;
 791      unsafe fn from_raw(raw: *mut raw::git_diff) -> Diff<'repo> {
 792          Diff {
 793 -            raw: raw,
 794 +            raw,
 795              _marker: marker::PhantomData,
 796          }
 797      }
 798 @@ -524,7 +545,7 @@
 799      type Raw = *mut raw::git_diff_delta;
 800      unsafe fn from_raw(raw: *mut raw::git_diff_delta) -> DiffDelta<'a> {
 801          DiffDelta {
 802 -            raw: raw,
 803 +            raw,
 804              _marker: marker::PhantomData,
 805          }
 806      }
 807 @@ -609,7 +630,7 @@
 808      type Raw = *const raw::git_diff_file;
 809      unsafe fn from_raw(raw: *const raw::git_diff_file) -> DiffFile<'a> {
 810          DiffFile {
 811 -            raw: raw,
 812 +            raw,
 813              _marker: marker::PhantomData,
 814          }
 815      }
 816 @@ -793,6 +814,11 @@
 817          self.flag(raw::GIT_DIFF_IGNORE_WHITESPACE_EOL, ignore)
 818      }
 819
 820 +    /// Ignore blank lines
 821 +    pub fn ignore_blank_lines(&mut self, ignore: bool) -> &mut DiffOptions {
 822 +        self.flag(raw::GIT_DIFF_IGNORE_BLANK_LINES, ignore)
 823 +    }
 824 +
 825      /// When generating patch text, include the content of untracked files.
 826      ///
 827      /// This automatically turns on `include_untracked` but it does not turn on
 828 @@ -931,6 +957,61 @@
 829  }
 830  impl<'diff> ExactSizeIterator for Deltas<'diff> {}
 831
 832 +/// Line origin constants.
 833 +#[derive(Copy, Clone, Debug, PartialEq)]
 834 +pub enum DiffLineType {
 835 +    /// These values will be sent to `git_diff_line_cb` along with the line
 836 +    Context,
 837 +    ///
 838 +    Addition,
 839 +    ///
 840 +    Deletion,
 841 +    /// Both files have no LF at end
 842 +    ContextEOFNL,
 843 +    /// Old has no LF at end, new does
 844 +    AddEOFNL,
 845 +    /// Old has LF at end, new does not
 846 +    DeleteEOFNL,
 847 +    /// The following values will only be sent to a `git_diff_line_cb` when
 848 +    /// the content of a diff is being formatted through `git_diff_print`.
 849 +    FileHeader,
 850 +    ///
 851 +    HunkHeader,
 852 +    /// For "Binary files x and y differ"
 853 +    Binary,
 854 +}
 855 +
 856 +impl Binding for DiffLineType {
 857 +    type Raw = raw::git_diff_line_t;
 858 +    unsafe fn from_raw(raw: raw::git_diff_line_t) -> Self {
 859 +        match raw {
 860 +            raw::GIT_DIFF_LINE_CONTEXT => DiffLineType::Context,
 861 +            raw::GIT_DIFF_LINE_ADDITION => DiffLineType::Addition,
 862 +            raw::GIT_DIFF_LINE_DELETION => DiffLineType::Deletion,
 863 +            raw::GIT_DIFF_LINE_CONTEXT_EOFNL => DiffLineType::ContextEOFNL,
 864 +            raw::GIT_DIFF_LINE_ADD_EOFNL => DiffLineType::AddEOFNL,
 865 +            raw::GIT_DIFF_LINE_DEL_EOFNL => DiffLineType::DeleteEOFNL,
 866 +            raw::GIT_DIFF_LINE_FILE_HDR => DiffLineType::FileHeader,
 867 +            raw::GIT_DIFF_LINE_HUNK_HDR => DiffLineType::HunkHeader,
 868 +            raw::GIT_DIFF_LINE_BINARY => DiffLineType::Binary,
 869 +            _ => panic!("Unknown git diff line type"),
 870 +        }
 871 +    }
 872 +    fn raw(&self) -> raw::git_diff_line_t {
 873 +        match *self {
 874 +            DiffLineType::Context => raw::GIT_DIFF_LINE_CONTEXT,
 875 +            DiffLineType::Addition => raw::GIT_DIFF_LINE_ADDITION,
 876 +            DiffLineType::Deletion => raw::GIT_DIFF_LINE_DELETION,
 877 +            DiffLineType::ContextEOFNL => raw::GIT_DIFF_LINE_CONTEXT_EOFNL,
 878 +            DiffLineType::AddEOFNL => raw::GIT_DIFF_LINE_ADD_EOFNL,
 879 +            DiffLineType::DeleteEOFNL => raw::GIT_DIFF_LINE_DEL_EOFNL,
 880 +            DiffLineType::FileHeader => raw::GIT_DIFF_LINE_FILE_HDR,
 881 +            DiffLineType::HunkHeader => raw::GIT_DIFF_LINE_HUNK_HDR,
 882 +            DiffLineType::Binary => raw::GIT_DIFF_LINE_BINARY,
 883 +        }
 884 +    }
 885 +}
 886 +
 887  impl<'a> DiffLine<'a> {
 888      /// Line number in old file or `None` for added line
 889      pub fn old_lineno(&self) -> Option<u32> {
 890 @@ -968,6 +1049,12 @@
 891          }
 892      }
 893
 894 +    /// origin of this `DiffLine`.
 895 +    ///
 896 +    pub fn origin_value(&self) -> DiffLineType {
 897 +        unsafe { Binding::from_raw((*self.raw).origin as raw::git_diff_line_t) }
 898 +    }
 899 +
 900      /// Sigil showing the origin of this `DiffLine`.
 901      ///
 902      ///  * ` ` - Line context
 903 @@ -999,7 +1086,7 @@
 904      type Raw = *const raw::git_diff_line;
 905      unsafe fn from_raw(raw: *const raw::git_diff_line) -> DiffLine<'a> {
 906          DiffLine {
 907 -            raw: raw,
 908 +            raw,
 909              _marker: marker::PhantomData,
 910          }
 911      }
 912 @@ -1061,7 +1148,7 @@
 913      type Raw = *const raw::git_diff_hunk;
 914      unsafe fn from_raw(raw: *const raw::git_diff_hunk) -> DiffHunk<'a> {
 915          DiffHunk {
 916 -            raw: raw,
 917 +            raw,
 918              _marker: marker::PhantomData,
 919          }
 920      }
 921 @@ -1083,7 +1170,7 @@
 922  }
 923
 924  impl DiffStats {
 925 -    /// Get the total number of files chaned in a diff.
 926 +    /// Get the total number of files changed in a diff.
 927      pub fn files_changed(&self) -> usize {
 928          unsafe { raw::git_diff_stats_files_changed(&*self.raw) as usize }
 929      }
 930 @@ -1117,7 +1204,7 @@
 931      type Raw = *mut raw::git_diff_stats;
 932
 933      unsafe fn from_raw(raw: *mut raw::git_diff_stats) -> DiffStats {
 934 -        DiffStats { raw: raw }
 935 +        DiffStats { raw }
 936      }
 937      fn raw(&self) -> *mut raw::git_diff_stats {
 938          self.raw
 939 @@ -1166,7 +1253,7 @@
 940      type Raw = *const raw::git_diff_binary;
 941      unsafe fn from_raw(raw: *const raw::git_diff_binary) -> DiffBinary<'a> {
 942          DiffBinary {
 943 -            raw: raw,
 944 +            raw,
 945              _marker: marker::PhantomData,
 946          }
 947      }
 948 @@ -1198,7 +1285,7 @@
 949      type Raw = *const raw::git_diff_binary_file;
 950      unsafe fn from_raw(raw: *const raw::git_diff_binary_file) -> DiffBinaryFile<'a> {
 951          DiffBinaryFile {
 952 -            raw: raw,
 953 +            raw,
 954              _marker: marker::PhantomData,
 955          }
 956      }
 957 @@ -1433,9 +1520,29 @@
 958      }
 959  }
 960
 961 +impl DiffPatchidOptions {
 962 +    /// Creates a new set of patchid options,
 963 +    /// initialized to the default values
 964 +    pub fn new() -> Self {
 965 +        let mut opts = DiffPatchidOptions {
 966 +            raw: unsafe { mem::zeroed() },
 967 +        };
 968 +        assert_eq!(
 969 +            unsafe {
 970 +                raw::git_diff_patchid_options_init(
 971 +                    &mut opts.raw,
 972 +                    raw::GIT_DIFF_PATCHID_OPTIONS_VERSION,
 973 +                )
 974 +            },
 975 +            0
 976 +        );
 977 +        opts
 978 +    }
 979 +}
 980 +
 981  #[cfg(test)]
 982  mod tests {
 983 -    use crate::{DiffOptions, Signature, Time};
 984 +    use crate::{DiffLineType, DiffOptions, Oid, Signature, Time};
 985      use std::borrow::Borrow;
 986      use std::fs::File;
 987      use std::io::Write;
 988 @@ -1450,6 +1557,8 @@
 989          assert_eq!(stats.insertions(), 0);
 990          assert_eq!(stats.deletions(), 0);
 991          assert_eq!(stats.files_changed(), 0);
 992 +        let patchid = diff.patchid(None).unwrap();
 993 +        assert_ne!(patchid, Oid::zero());
 994      }
 995
 996      #[test]
 997 @@ -1684,4 +1793,58 @@
 998              assert_eq!(line.trim(), "")
 999          }
1000      }
1001 +
1002 +    #[test]
1003 +    fn foreach_diff_line_origin_value() {
1004 +        let foo_path = Path::new("foo");
1005 +        let (td, repo) = crate::test::repo_init();
1006 +        t!(t!(File::create(&td.path().join(foo_path))).write_all(b"bar\n"));
1007 +        let mut index = t!(repo.index());
1008 +        t!(index.add_path(foo_path));
1009 +        let mut opts = DiffOptions::new();
1010 +        opts.include_untracked(true);
1011 +        let diff = t!(repo.diff_tree_to_index(None, Some(&index), Some(&mut opts)));
1012 +        let mut origin_values: Vec<DiffLineType> = Vec::new();
1013 +        t!(diff.foreach(
1014 +            &mut |_file, _progress| { true },
1015 +            None,
1016 +            None,
1017 +            Some(&mut |_file, _hunk, line| {
1018 +                origin_values.push(line.origin_value());
1019 +                true
1020 +            })
1021 +        ));
1022 +        assert_eq!(origin_values.len(), 1);
1023 +        assert_eq!(origin_values[0], DiffLineType::Addition);
1024 +    }
1025 +
1026 +    #[test]
1027 +    fn foreach_exits_with_euser() {
1028 +        let foo_path = Path::new("foo");
1029 +        let bar_path = Path::new("foo");
1030 +
1031 +        let (td, repo) = crate::test::repo_init();
1032 +        t!(t!(File::create(&td.path().join(foo_path))).write_all(b"bar\n"));
1033 +
1034 +        let mut index = t!(repo.index());
1035 +        t!(index.add_path(foo_path));
1036 +        t!(index.add_path(bar_path));
1037 +
1038 +        let mut opts = DiffOptions::new();
1039 +        opts.include_untracked(true);
1040 +        let diff = t!(repo.diff_tree_to_index(None, Some(&index), Some(&mut opts)));
1041 +
1042 +        let mut calls = 0;
1043 +        let result = diff.foreach(
1044 +            &mut |_file, _progress| {
1045 +                calls += 1;
1046 +                false
1047 +            },
1048 +            None,
1049 +            None,
1050 +            None,
1051 +        );
1052 +
1053 +        assert_eq!(result.unwrap_err().code(), crate::ErrorCode::User);
1054 +    }
1055  }
1056 diff -urN rustc-1.56.0-src/vendor/git2/src/error.rs rustc-1.56.0-src-git2/vendor/git2/src/error.rs
1057 --- rustc-1.56.0-src/vendor/git2/src/error.rs   2021-10-18 13:05:54.000000000 +0200
1058 +++ rustc-1.56.0-src-git2/vendor/git2/src/error.rs      2021-10-23 20:47:39.255788944 +0200
1059 @@ -69,12 +69,12 @@
1060      }
1061
1062      unsafe fn from_raw(code: c_int, ptr: *const raw::git_error) -> Error {
1063 -        let msg = CStr::from_ptr((*ptr).message as *const _).to_bytes();
1064 -        let msg = String::from_utf8_lossy(msg).into_owned();
1065 +        let message = CStr::from_ptr((*ptr).message as *const _).to_bytes();
1066 +        let message = String::from_utf8_lossy(message).into_owned();
1067          Error {
1068 -            code: code,
1069 +            code,
1070              klass: (*ptr).klass,
1071 -            message: msg,
1072 +            message,
1073          }
1074      }
1075
1076 diff -urN rustc-1.56.0-src/vendor/git2/src/index.rs rustc-1.56.0-src-git2/vendor/git2/src/index.rs
1077 --- rustc-1.56.0-src/vendor/git2/src/index.rs   2021-10-18 13:05:54.000000000 +0200
1078 +++ rustc-1.56.0-src-git2/vendor/git2/src/index.rs      2021-10-23 20:47:39.255788944 +0200
1079 @@ -166,7 +166,7 @@
1080                  gid: entry.gid,
1081                  file_size: entry.file_size,
1082                  id: *entry.id.raw(),
1083 -                flags: flags,
1084 +                flags,
1085                  flags_extended: entry.flags_extended,
1086                  path: path.as_ptr(),
1087                  mtime: raw::git_index_time {
1088 @@ -223,7 +223,7 @@
1089                  gid: entry.gid,
1090                  file_size: entry.file_size,
1091                  id: *entry.id.raw(),
1092 -                flags: flags,
1093 +                flags,
1094                  flags_extended: entry.flags_extended,
1095                  path: path.as_ptr(),
1096                  mtime: raw::git_index_time {
1097 @@ -600,7 +600,7 @@
1098  impl Binding for Index {
1099      type Raw = *mut raw::git_index;
1100      unsafe fn from_raw(raw: *mut raw::git_index) -> Index {
1101 -        Index { raw: raw }
1102 +        Index { raw }
1103      }
1104      fn raw(&self) -> *mut raw::git_index {
1105          self.raw
1106 @@ -718,15 +718,15 @@
1107          let path = slice::from_raw_parts(path as *const u8, pathlen);
1108
1109          IndexEntry {
1110 -            dev: dev,
1111 -            ino: ino,
1112 -            mode: mode,
1113 -            uid: uid,
1114 -            gid: gid,
1115 -            file_size: file_size,
1116 +            dev,
1117 +            ino,
1118 +            mode,
1119 +            uid,
1120 +            gid,
1121 +            file_size,
1122              id: Binding::from_raw(&id as *const _),
1123 -            flags: flags,
1124 -            flags_extended: flags_extended,
1125 +            flags,
1126 +            flags_extended,
1127              path: path.to_vec(),
1128              mtime: Binding::from_raw(mtime),
1129              ctime: Binding::from_raw(ctime),
1130 diff -urN rustc-1.56.0-src/vendor/git2/src/lib.rs rustc-1.56.0-src-git2/vendor/git2/src/lib.rs
1131 --- rustc-1.56.0-src/vendor/git2/src/lib.rs     2021-10-18 13:05:54.000000000 +0200
1132 +++ rustc-1.56.0-src-git2/vendor/git2/src/lib.rs        2021-10-23 20:47:39.255788944 +0200
1133 @@ -80,6 +80,7 @@
1134  use std::sync::Once;
1135
1136  pub use crate::apply::{ApplyLocation, ApplyOptions};
1137 +pub use crate::attr::AttrValue;
1138  pub use crate::blame::{Blame, BlameHunk, BlameIter, BlameOptions};
1139  pub use crate::blob::{Blob, BlobWriter};
1140  pub use crate::branch::{Branch, Branches};
1141 @@ -91,15 +92,20 @@
1142  pub use crate::describe::{Describe, DescribeFormatOptions, DescribeOptions};
1143  pub use crate::diff::{Deltas, Diff, DiffDelta, DiffFile, DiffOptions};
1144  pub use crate::diff::{DiffBinary, DiffBinaryFile, DiffBinaryKind};
1145 -pub use crate::diff::{DiffFindOptions, DiffHunk, DiffLine, DiffStats};
1146 +pub use crate::diff::{DiffFindOptions, DiffHunk, DiffLine, DiffLineType, DiffStats};
1147  pub use crate::error::Error;
1148  pub use crate::index::{
1149      Index, IndexConflict, IndexConflicts, IndexEntries, IndexEntry, IndexMatchedPath,
1150  };
1151  pub use crate::indexer::{IndexerProgress, Progress};
1152 +pub use crate::mailmap::Mailmap;
1153  pub use crate::mempack::Mempack;
1154  pub use crate::merge::{AnnotatedCommit, MergeOptions};
1155 -pub use crate::message::{message_prettify, DEFAULT_COMMENT_CHAR};
1156 +pub use crate::message::{
1157 +    message_prettify, message_trailers_bytes, message_trailers_strs, MessageTrailersBytes,
1158 +    MessageTrailersBytesIterator, MessageTrailersStrs, MessageTrailersStrsIterator,
1159 +    DEFAULT_COMMENT_CHAR,
1160 +};
1161  pub use crate::note::{Note, Notes};
1162  pub use crate::object::Object;
1163  pub use crate::odb::{Odb, OdbObject, OdbPackwriter, OdbReader, OdbWriter};
1164 @@ -128,9 +134,12 @@
1165  pub use crate::submodule::{Submodule, SubmoduleUpdateOptions};
1166  pub use crate::tag::Tag;
1167  pub use crate::time::{IndexTime, Time};
1168 +pub use crate::tracing::{trace_set, TraceLevel};
1169 +pub use crate::transaction::Transaction;
1170  pub use crate::tree::{Tree, TreeEntry, TreeIter, TreeWalkMode, TreeWalkResult};
1171  pub use crate::treebuilder::TreeBuilder;
1172  pub use crate::util::IntoCString;
1173 +pub use crate::version::Version;
1174  pub use crate::worktree::{Worktree, WorktreeAddOptions, WorktreeLockStatus, WorktreePruneOptions};
1175
1176  // Create a convinience method on bitflag struct which checks the given flag
1177 @@ -633,6 +642,7 @@
1178  mod test;
1179  #[macro_use]
1180  mod panic;
1181 +mod attr;
1182  mod call;
1183  mod util;
1184
1185 @@ -657,6 +667,7 @@
1186  mod error;
1187  mod index;
1188  mod indexer;
1189 +mod mailmap;
1190  mod mempack;
1191  mod merge;
1192  mod message;
1193 @@ -685,8 +696,11 @@
1194  mod tag;
1195  mod tagforeach;
1196  mod time;
1197 +mod tracing;
1198 +mod transaction;
1199  mod tree;
1200  mod treebuilder;
1201 +mod version;
1202  mod worktree;
1203
1204  fn init() {
1205 @@ -929,6 +943,34 @@
1206      }
1207  }
1208
1209 +impl SubmoduleIgnore {
1210 +    /// Converts a [`raw::git_submodule_ignore_t`] to a [`SubmoduleIgnore`]
1211 +    pub fn from_raw(raw: raw::git_submodule_ignore_t) -> Self {
1212 +        match raw {
1213 +            raw::GIT_SUBMODULE_IGNORE_UNSPECIFIED => SubmoduleIgnore::Unspecified,
1214 +            raw::GIT_SUBMODULE_IGNORE_NONE => SubmoduleIgnore::None,
1215 +            raw::GIT_SUBMODULE_IGNORE_UNTRACKED => SubmoduleIgnore::Untracked,
1216 +            raw::GIT_SUBMODULE_IGNORE_DIRTY => SubmoduleIgnore::Dirty,
1217 +            raw::GIT_SUBMODULE_IGNORE_ALL => SubmoduleIgnore::All,
1218 +            n => panic!("unknown submodule ignore rule: {}", n),
1219 +        }
1220 +    }
1221 +}
1222 +
1223 +impl SubmoduleUpdate {
1224 +    /// Converts a [`raw::git_submodule_update_t`] to a [`SubmoduleUpdate`]
1225 +    pub fn from_raw(raw: raw::git_submodule_update_t) -> Self {
1226 +        match raw {
1227 +            raw::GIT_SUBMODULE_UPDATE_CHECKOUT => SubmoduleUpdate::Checkout,
1228 +            raw::GIT_SUBMODULE_UPDATE_REBASE => SubmoduleUpdate::Rebase,
1229 +            raw::GIT_SUBMODULE_UPDATE_MERGE => SubmoduleUpdate::Merge,
1230 +            raw::GIT_SUBMODULE_UPDATE_NONE => SubmoduleUpdate::None,
1231 +            raw::GIT_SUBMODULE_UPDATE_DEFAULT => SubmoduleUpdate::Default,
1232 +            n => panic!("unknown submodule update strategy: {}", n),
1233 +        }
1234 +    }
1235 +}
1236 +
1237  bitflags! {
1238      /// Status flags for a single file
1239      ///
1240 @@ -1171,6 +1213,7 @@
1241  /// These values represent settings for the `submodule.$name.ignore`
1242  /// configuration value which says how deeply to look at the working
1243  /// directory when getting the submodule status.
1244 +#[derive(Debug)]
1245  pub enum SubmoduleIgnore {
1246      /// Use the submodule's configuration
1247      Unspecified,
1248 @@ -1184,6 +1227,31 @@
1249      All,
1250  }
1251
1252 +/// Submodule update values
1253 +///
1254 +/// These values represent settings for the `submodule.$name.update`
1255 +/// configuration value which says how to handle `git submodule update`
1256 +/// for this submodule. The value is usually set in the ".gitmodules"
1257 +/// file and copied to ".git/config" when the submodule is initialized.
1258 +#[derive(Debug)]
1259 +pub enum SubmoduleUpdate {
1260 +    /// The default; when a submodule is updated, checkout the new detached
1261 +    /// HEAD to the submodule directory.
1262 +    Checkout,
1263 +    /// Update by rebasing the current checked out branch onto the commit from
1264 +    /// the superproject.
1265 +    Rebase,
1266 +    /// Update by merging the commit in the superproject into the current
1267 +    /// checkout out branch of the submodule.
1268 +    Merge,
1269 +    /// Do not update this submodule even when the commit in the superproject
1270 +    /// is updated.
1271 +    None,
1272 +    /// Not used except as static initializer when we don't want any particular
1273 +    /// update rule to be specified.
1274 +    Default,
1275 +}
1276 +
1277  bitflags! {
1278      /// ...
1279      pub struct PathspecFlags: u32 {
1280 diff -urN rustc-1.56.0-src/vendor/git2/src/mailmap.rs rustc-1.56.0-src-git2/vendor/git2/src/mailmap.rs
1281 --- rustc-1.56.0-src/vendor/git2/src/mailmap.rs 1970-01-01 01:00:00.000000000 +0100
1282 +++ rustc-1.56.0-src-git2/vendor/git2/src/mailmap.rs    2021-10-23 20:47:39.255788944 +0200
1283 @@ -0,0 +1,134 @@
1284 +use std::ffi::CString;
1285 +use std::ptr;
1286 +
1287 +use crate::util::Binding;
1288 +use crate::{raw, Error, Signature};
1289 +
1290 +/// A structure to represent a repository's .mailmap file.
1291 +///
1292 +/// The representation cannot be written to disk.
1293 +pub struct Mailmap {
1294 +    raw: *mut raw::git_mailmap,
1295 +}
1296 +
1297 +impl Binding for Mailmap {
1298 +    type Raw = *mut raw::git_mailmap;
1299 +
1300 +    unsafe fn from_raw(ptr: *mut raw::git_mailmap) -> Mailmap {
1301 +        Mailmap { raw: ptr }
1302 +    }
1303 +
1304 +    fn raw(&self) -> *mut raw::git_mailmap {
1305 +        self.raw
1306 +    }
1307 +}
1308 +
1309 +impl Drop for Mailmap {
1310 +    fn drop(&mut self) {
1311 +        unsafe {
1312 +            raw::git_mailmap_free(self.raw);
1313 +        }
1314 +    }
1315 +}
1316 +
1317 +impl Mailmap {
1318 +    /// Creates an empty, in-memory mailmap object.
1319 +    pub fn new() -> Result<Mailmap, Error> {
1320 +        crate::init();
1321 +        let mut ret = ptr::null_mut();
1322 +        unsafe {
1323 +            try_call!(raw::git_mailmap_new(&mut ret));
1324 +            Ok(Binding::from_raw(ret))
1325 +        }
1326 +    }
1327 +
1328 +    /// Creates an in-memory mailmap object representing the given buffer.
1329 +    pub fn from_buffer(buf: &str) -> Result<Mailmap, Error> {
1330 +        crate::init();
1331 +        let mut ret = ptr::null_mut();
1332 +        let len = buf.len();
1333 +        let buf = CString::new(buf)?;
1334 +        unsafe {
1335 +            try_call!(raw::git_mailmap_from_buffer(&mut ret, buf, len));
1336 +            Ok(Binding::from_raw(ret))
1337 +        }
1338 +    }
1339 +
1340 +    /// Adds a new entry to this in-memory mailmap object.
1341 +    pub fn add_entry(
1342 +        &mut self,
1343 +        real_name: Option<&str>,
1344 +        real_email: Option<&str>,
1345 +        replace_name: Option<&str>,
1346 +        replace_email: &str,
1347 +    ) -> Result<(), Error> {
1348 +        let real_name = crate::opt_cstr(real_name)?;
1349 +        let real_email = crate::opt_cstr(real_email)?;
1350 +        let replace_name = crate::opt_cstr(replace_name)?;
1351 +        let replace_email = CString::new(replace_email)?;
1352 +        unsafe {
1353 +            try_call!(raw::git_mailmap_add_entry(
1354 +                self.raw,
1355 +                real_name,
1356 +                real_email,
1357 +                replace_name,
1358 +                replace_email
1359 +            ));
1360 +            Ok(())
1361 +        }
1362 +    }
1363 +
1364 +    /// Resolves a signature to its real name and email address.
1365 +    pub fn resolve_signature(&self, sig: &Signature<'_>) -> Result<Signature<'static>, Error> {
1366 +        let mut ret = ptr::null_mut();
1367 +        unsafe {
1368 +            try_call!(raw::git_mailmap_resolve_signature(
1369 +                &mut ret,
1370 +                &*self.raw,
1371 +                sig.raw()
1372 +            ));
1373 +            Ok(Binding::from_raw(ret))
1374 +        }
1375 +    }
1376 +}
1377 +
1378 +#[cfg(test)]
1379 +mod tests {
1380 +    use super::*;
1381 +
1382 +    #[test]
1383 +    fn smoke() {
1384 +        let sig_name = "name";
1385 +        let sig_email = "email";
1386 +        let sig = t!(Signature::now(sig_name, sig_email));
1387 +
1388 +        let mut mm = t!(Mailmap::new());
1389 +
1390 +        let mailmapped_sig = t!(mm.resolve_signature(&sig));
1391 +        assert_eq!(mailmapped_sig.name(), Some(sig_name));
1392 +        assert_eq!(mailmapped_sig.email(), Some(sig_email));
1393 +
1394 +        t!(mm.add_entry(None, None, None, sig_email));
1395 +        t!(mm.add_entry(
1396 +            Some("real name"),
1397 +            Some("real@email"),
1398 +            Some(sig_name),
1399 +            sig_email,
1400 +        ));
1401 +
1402 +        let mailmapped_sig = t!(mm.resolve_signature(&sig));
1403 +        assert_eq!(mailmapped_sig.name(), Some("real name"));
1404 +        assert_eq!(mailmapped_sig.email(), Some("real@email"));
1405 +    }
1406 +
1407 +    #[test]
1408 +    fn from_buffer() {
1409 +        let buf = "<prøper@emæil> <email>";
1410 +        let mm = t!(Mailmap::from_buffer(&buf));
1411 +
1412 +        let sig = t!(Signature::now("name", "email"));
1413 +        let mailmapped_sig = t!(mm.resolve_signature(&sig));
1414 +        assert_eq!(mailmapped_sig.name(), Some("name"));
1415 +        assert_eq!(mailmapped_sig.email(), Some("prøper@emæil"));
1416 +    }
1417 +}
1418 diff -urN rustc-1.56.0-src/vendor/git2/src/mempack.rs rustc-1.56.0-src-git2/vendor/git2/src/mempack.rs
1419 --- rustc-1.56.0-src/vendor/git2/src/mempack.rs 2021-10-18 13:05:54.000000000 +0200
1420 +++ rustc-1.56.0-src-git2/vendor/git2/src/mempack.rs    2021-10-23 20:47:39.255788944 +0200
1421 @@ -16,7 +16,7 @@
1422
1423      unsafe fn from_raw(raw: *mut raw::git_odb_backend) -> Mempack<'odb> {
1424          Mempack {
1425 -            raw: raw,
1426 +            raw,
1427              _marker: marker::PhantomData,
1428          }
1429      }
1430 diff -urN rustc-1.56.0-src/vendor/git2/src/merge.rs rustc-1.56.0-src-git2/vendor/git2/src/merge.rs
1431 --- rustc-1.56.0-src/vendor/git2/src/merge.rs   2021-10-18 13:05:54.000000000 +0200
1432 +++ rustc-1.56.0-src-git2/vendor/git2/src/merge.rs      2021-10-23 20:47:39.255788944 +0200
1433 @@ -178,7 +178,7 @@
1434      type Raw = *mut raw::git_annotated_commit;
1435      unsafe fn from_raw(raw: *mut raw::git_annotated_commit) -> AnnotatedCommit<'repo> {
1436          AnnotatedCommit {
1437 -            raw: raw,
1438 +            raw,
1439              _marker: marker::PhantomData,
1440          }
1441      }
1442 diff -urN rustc-1.56.0-src/vendor/git2/src/message.rs rustc-1.56.0-src-git2/vendor/git2/src/message.rs
1443 --- rustc-1.56.0-src/vendor/git2/src/message.rs 2021-10-18 13:05:54.000000000 +0200
1444 +++ rustc-1.56.0-src-git2/vendor/git2/src/message.rs    2021-10-23 20:47:39.255788944 +0200
1445 @@ -1,4 +1,7 @@
1446 +use core::ops::Range;
1447 +use std::ffi::CStr;
1448  use std::ffi::CString;
1449 +use std::ptr;
1450
1451  use libc::{c_char, c_int};
1452
1453 @@ -31,12 +34,216 @@
1454  /// The default comment character for `message_prettify` ('#')
1455  pub const DEFAULT_COMMENT_CHAR: Option<u8> = Some(b'#');
1456
1457 +/// Get the trailers for the given message.
1458 +///
1459 +/// Use this function when you are dealing with a UTF-8-encoded message.
1460 +pub fn message_trailers_strs(message: &str) -> Result<MessageTrailersStrs, Error> {
1461 +    _message_trailers(message.into_c_string()?).map(|res| MessageTrailersStrs(res))
1462 +}
1463 +
1464 +/// Get the trailers for the given message.
1465 +///
1466 +/// Use this function when the message might not be UTF-8-encoded,
1467 +/// or if you want to handle the returned trailer key–value pairs
1468 +/// as bytes.
1469 +pub fn message_trailers_bytes<S: IntoCString>(message: S) -> Result<MessageTrailersBytes, Error> {
1470 +    _message_trailers(message.into_c_string()?).map(|res| MessageTrailersBytes(res))
1471 +}
1472 +
1473 +fn _message_trailers(message: CString) -> Result<MessageTrailers, Error> {
1474 +    let ret = MessageTrailers::new();
1475 +    unsafe {
1476 +        try_call!(raw::git_message_trailers(ret.raw(), message));
1477 +    }
1478 +    Ok(ret)
1479 +}
1480 +
1481 +/// Collection of UTF-8-encoded trailers.
1482 +///
1483 +/// Use `iter()` to get access to the values.
1484 +pub struct MessageTrailersStrs(MessageTrailers);
1485 +
1486 +impl MessageTrailersStrs {
1487 +    /// Create a borrowed iterator.
1488 +    pub fn iter(&self) -> MessageTrailersStrsIterator<'_> {
1489 +        MessageTrailersStrsIterator(self.0.iter())
1490 +    }
1491 +    /// The number of trailer key–value pairs.
1492 +    pub fn len(&self) -> usize {
1493 +        self.0.len()
1494 +    }
1495 +    /// Convert to the “bytes” variant.
1496 +    pub fn to_bytes(self) -> MessageTrailersBytes {
1497 +        MessageTrailersBytes(self.0)
1498 +    }
1499 +}
1500 +
1501 +/// Collection of unencoded (bytes) trailers.
1502 +///
1503 +/// Use `iter()` to get access to the values.
1504 +pub struct MessageTrailersBytes(MessageTrailers);
1505 +
1506 +impl MessageTrailersBytes {
1507 +    /// Create a borrowed iterator.
1508 +    pub fn iter(&self) -> MessageTrailersBytesIterator<'_> {
1509 +        MessageTrailersBytesIterator(self.0.iter())
1510 +    }
1511 +    /// The number of trailer key–value pairs.
1512 +    pub fn len(&self) -> usize {
1513 +        self.0.len()
1514 +    }
1515 +}
1516 +
1517 +struct MessageTrailers {
1518 +    raw: raw::git_message_trailer_array,
1519 +}
1520 +
1521 +impl MessageTrailers {
1522 +    fn new() -> MessageTrailers {
1523 +        crate::init();
1524 +        unsafe {
1525 +            Binding::from_raw(&mut raw::git_message_trailer_array {
1526 +                trailers: ptr::null_mut(),
1527 +                count: 0,
1528 +                _trailer_block: ptr::null_mut(),
1529 +            } as *mut _)
1530 +        }
1531 +    }
1532 +    fn iter(&self) -> MessageTrailersIterator<'_> {
1533 +        MessageTrailersIterator {
1534 +            trailers: self,
1535 +            range: Range {
1536 +                start: 0,
1537 +                end: self.raw.count,
1538 +            },
1539 +        }
1540 +    }
1541 +    fn len(&self) -> usize {
1542 +        self.raw.count
1543 +    }
1544 +}
1545 +
1546 +impl Drop for MessageTrailers {
1547 +    fn drop(&mut self) {
1548 +        unsafe {
1549 +            raw::git_message_trailer_array_free(&mut self.raw);
1550 +        }
1551 +    }
1552 +}
1553 +
1554 +impl Binding for MessageTrailers {
1555 +    type Raw = *mut raw::git_message_trailer_array;
1556 +    unsafe fn from_raw(raw: *mut raw::git_message_trailer_array) -> MessageTrailers {
1557 +        MessageTrailers { raw: *raw }
1558 +    }
1559 +    fn raw(&self) -> *mut raw::git_message_trailer_array {
1560 +        &self.raw as *const _ as *mut _
1561 +    }
1562 +}
1563 +
1564 +struct MessageTrailersIterator<'a> {
1565 +    trailers: &'a MessageTrailers,
1566 +    range: Range<usize>,
1567 +}
1568 +
1569 +fn to_raw_tuple(trailers: &MessageTrailers, index: usize) -> (*const c_char, *const c_char) {
1570 +    unsafe {
1571 +        let addr = trailers.raw.trailers.wrapping_add(index);
1572 +        ((*addr).key, (*addr).value)
1573 +    }
1574 +}
1575 +
1576 +/// Borrowed iterator over the UTF-8-encoded trailers.
1577 +pub struct MessageTrailersStrsIterator<'a>(MessageTrailersIterator<'a>);
1578 +
1579 +impl<'pair> Iterator for MessageTrailersStrsIterator<'pair> {
1580 +    type Item = (&'pair str, &'pair str);
1581 +
1582 +    fn next(&mut self) -> Option<Self::Item> {
1583 +        self.0
1584 +            .range
1585 +            .next()
1586 +            .map(|index| to_str_tuple(&self.0.trailers, index))
1587 +    }
1588 +
1589 +    fn size_hint(&self) -> (usize, Option<usize>) {
1590 +        self.0.range.size_hint()
1591 +    }
1592 +}
1593 +
1594 +impl ExactSizeIterator for MessageTrailersStrsIterator<'_> {
1595 +    fn len(&self) -> usize {
1596 +        self.0.range.len()
1597 +    }
1598 +}
1599 +
1600 +impl DoubleEndedIterator for MessageTrailersStrsIterator<'_> {
1601 +    fn next_back(&mut self) -> Option<Self::Item> {
1602 +        self.0
1603 +            .range
1604 +            .next_back()
1605 +            .map(|index| to_str_tuple(&self.0.trailers, index))
1606 +    }
1607 +}
1608 +
1609 +fn to_str_tuple(trailers: &MessageTrailers, index: usize) -> (&str, &str) {
1610 +    unsafe {
1611 +        let (rkey, rvalue) = to_raw_tuple(&trailers, index);
1612 +        let key = CStr::from_ptr(rkey).to_str().unwrap();
1613 +        let value = CStr::from_ptr(rvalue).to_str().unwrap();
1614 +        (key, value)
1615 +    }
1616 +}
1617 +
1618 +/// Borrowed iterator over the raw (bytes) trailers.
1619 +pub struct MessageTrailersBytesIterator<'a>(MessageTrailersIterator<'a>);
1620 +
1621 +impl<'pair> Iterator for MessageTrailersBytesIterator<'pair> {
1622 +    type Item = (&'pair [u8], &'pair [u8]);
1623 +
1624 +    fn next(&mut self) -> Option<Self::Item> {
1625 +        self.0
1626 +            .range
1627 +            .next()
1628 +            .map(|index| to_bytes_tuple(&self.0.trailers, index))
1629 +    }
1630 +
1631 +    fn size_hint(&self) -> (usize, Option<usize>) {
1632 +        self.0.range.size_hint()
1633 +    }
1634 +}
1635 +
1636 +impl ExactSizeIterator for MessageTrailersBytesIterator<'_> {
1637 +    fn len(&self) -> usize {
1638 +        self.0.range.len()
1639 +    }
1640 +}
1641 +
1642 +impl DoubleEndedIterator for MessageTrailersBytesIterator<'_> {
1643 +    fn next_back(&mut self) -> Option<Self::Item> {
1644 +        self.0
1645 +            .range
1646 +            .next_back()
1647 +            .map(|index| to_bytes_tuple(&self.0.trailers, index))
1648 +    }
1649 +}
1650 +
1651 +fn to_bytes_tuple(trailers: &MessageTrailers, index: usize) -> (&[u8], &[u8]) {
1652 +    unsafe {
1653 +        let (rkey, rvalue) = to_raw_tuple(&trailers, index);
1654 +        let key = CStr::from_ptr(rkey).to_bytes();
1655 +        let value = CStr::from_ptr(rvalue).to_bytes();
1656 +        (key, value)
1657 +    }
1658 +}
1659 +
1660  #[cfg(test)]
1661  mod tests {
1662 -    use crate::{message_prettify, DEFAULT_COMMENT_CHAR};
1663
1664      #[test]
1665      fn prettify() {
1666 +        use crate::{message_prettify, DEFAULT_COMMENT_CHAR};
1667 +
1668          // This does not attempt to duplicate the extensive tests for
1669          // git_message_prettify in libgit2, just a few representative values to
1670          // make sure the interface works as expected.
1671 @@ -58,4 +265,80 @@
1672              "1\n"
1673          );
1674      }
1675 +
1676 +    #[test]
1677 +    fn trailers() {
1678 +        use crate::{message_trailers_bytes, message_trailers_strs, MessageTrailersStrs};
1679 +        use std::collections::HashMap;
1680 +
1681 +        // no trailers
1682 +        let message1 = "
1683 +WHAT ARE WE HERE FOR
1684 +
1685 +What are we here for?
1686 +
1687 +Just to be eaten?
1688 +";
1689 +        let expected: HashMap<&str, &str> = HashMap::new();
1690 +        assert_eq!(expected, to_map(&message_trailers_strs(message1).unwrap()));
1691 +
1692 +        // standard PSA
1693 +        let message2 = "
1694 +Attention all
1695 +
1696 +We are out of tomatoes.
1697 +
1698 +Spoken-by: Major Turnips
1699 +Transcribed-by: Seargant Persimmons
1700 +Signed-off-by: Colonel Kale
1701 +";
1702 +        let expected: HashMap<&str, &str> = vec![
1703 +            ("Spoken-by", "Major Turnips"),
1704 +            ("Transcribed-by", "Seargant Persimmons"),
1705 +            ("Signed-off-by", "Colonel Kale"),
1706 +        ]
1707 +        .into_iter()
1708 +        .collect();
1709 +        assert_eq!(expected, to_map(&message_trailers_strs(message2).unwrap()));
1710 +
1711 +        // ignore everything after `---`
1712 +        let message3 = "
1713 +The fate of Seargant Green-Peppers
1714 +
1715 +Seargant Green-Peppers was killed by Caterpillar Battalion 44.
1716 +
1717 +Signed-off-by: Colonel Kale
1718 +---
1719 +I never liked that guy, anyway.
1720 +
1721 +Opined-by: Corporal Garlic
1722 +";
1723 +        let expected: HashMap<&str, &str> = vec![("Signed-off-by", "Colonel Kale")]
1724 +            .into_iter()
1725 +            .collect();
1726 +        assert_eq!(expected, to_map(&message_trailers_strs(message3).unwrap()));
1727 +
1728 +        // Raw bytes message; not valid UTF-8
1729 +        // Source: https://stackoverflow.com/a/3886015/1725151
1730 +        let message4 = b"
1731 +Be honest guys
1732 +
1733 +Am I a malformed brussels sprout?
1734 +
1735 +Signed-off-by: Lieutenant \xe2\x28\xa1prout
1736 +";
1737 +
1738 +        let trailer = message_trailers_bytes(&message4[..]).unwrap();
1739 +        let expected = (&b"Signed-off-by"[..], &b"Lieutenant \xe2\x28\xa1prout"[..]);
1740 +        let actual = trailer.iter().next().unwrap();
1741 +        assert_eq!(expected, actual);
1742 +
1743 +        fn to_map(trailers: &MessageTrailersStrs) -> HashMap<&str, &str> {
1744 +            let mut map = HashMap::with_capacity(trailers.len());
1745 +            for (key, value) in trailers.iter() {
1746 +                map.insert(key, value);
1747 +            }
1748 +            map
1749 +        }
1750 +    }
1751  }
1752 diff -urN rustc-1.56.0-src/vendor/git2/src/note.rs rustc-1.56.0-src-git2/vendor/git2/src/note.rs
1753 --- rustc-1.56.0-src/vendor/git2/src/note.rs    2021-10-18 13:05:54.000000000 +0200
1754 +++ rustc-1.56.0-src-git2/vendor/git2/src/note.rs       2021-10-23 20:47:39.255788944 +0200
1755 @@ -53,7 +53,7 @@
1756      type Raw = *mut raw::git_note;
1757      unsafe fn from_raw(raw: *mut raw::git_note) -> Note<'repo> {
1758          Note {
1759 -            raw: raw,
1760 +            raw,
1761              _marker: marker::PhantomData,
1762          }
1763      }
1764 @@ -80,7 +80,7 @@
1765      type Raw = *mut raw::git_note_iterator;
1766      unsafe fn from_raw(raw: *mut raw::git_note_iterator) -> Notes<'repo> {
1767          Notes {
1768 -            raw: raw,
1769 +            raw,
1770              _marker: marker::PhantomData,
1771          }
1772      }
1773 diff -urN rustc-1.56.0-src/vendor/git2/src/object.rs rustc-1.56.0-src-git2/vendor/git2/src/object.rs
1774 --- rustc-1.56.0-src/vendor/git2/src/object.rs  2021-10-18 13:05:54.000000000 +0200
1775 +++ rustc-1.56.0-src-git2/vendor/git2/src/object.rs     2021-10-23 20:47:39.255788944 +0200
1776 @@ -232,7 +232,7 @@
1777
1778      unsafe fn from_raw(raw: *mut raw::git_object) -> Object<'repo> {
1779          Object {
1780 -            raw: raw,
1781 +            raw,
1782              _marker: marker::PhantomData,
1783          }
1784      }
1785 diff -urN rustc-1.56.0-src/vendor/git2/src/odb.rs rustc-1.56.0-src-git2/vendor/git2/src/odb.rs
1786 --- rustc-1.56.0-src/vendor/git2/src/odb.rs     2021-10-18 13:05:54.000000000 +0200
1787 +++ rustc-1.56.0-src-git2/vendor/git2/src/odb.rs        2021-10-23 20:47:39.255788944 +0200
1788 @@ -23,7 +23,7 @@
1789
1790      unsafe fn from_raw(raw: *mut raw::git_odb) -> Odb<'repo> {
1791          Odb {
1792 -            raw: raw,
1793 +            raw,
1794              _marker: marker::PhantomData,
1795          }
1796      }
1797 @@ -273,7 +273,7 @@
1798
1799      unsafe fn from_raw(raw: *mut raw::git_odb_object) -> OdbObject<'a> {
1800          OdbObject {
1801 -            raw: raw,
1802 +            raw,
1803              _marker: marker::PhantomData,
1804          }
1805      }
1806 @@ -327,7 +327,7 @@
1807
1808      unsafe fn from_raw(raw: *mut raw::git_odb_stream) -> OdbReader<'repo> {
1809          OdbReader {
1810 -            raw: raw,
1811 +            raw,
1812              _marker: marker::PhantomData,
1813          }
1814      }
1815 @@ -386,7 +386,7 @@
1816
1817      unsafe fn from_raw(raw: *mut raw::git_odb_stream) -> OdbWriter<'repo> {
1818          OdbWriter {
1819 -            raw: raw,
1820 +            raw,
1821              _marker: marker::PhantomData,
1822          }
1823      }
1824 diff -urN rustc-1.56.0-src/vendor/git2/src/oid_array.rs rustc-1.56.0-src-git2/vendor/git2/src/oid_array.rs
1825 --- rustc-1.56.0-src/vendor/git2/src/oid_array.rs       2021-10-18 13:05:54.000000000 +0200
1826 +++ rustc-1.56.0-src-git2/vendor/git2/src/oid_array.rs  2021-10-23 20:47:39.255788944 +0200
1827 @@ -32,7 +32,7 @@
1828  impl Binding for OidArray {
1829      type Raw = raw::git_oidarray;
1830      unsafe fn from_raw(raw: raw::git_oidarray) -> OidArray {
1831 -        OidArray { raw: raw }
1832 +        OidArray { raw }
1833      }
1834      fn raw(&self) -> raw::git_oidarray {
1835          self.raw
1836 diff -urN rustc-1.56.0-src/vendor/git2/src/oid.rs rustc-1.56.0-src-git2/vendor/git2/src/oid.rs
1837 --- rustc-1.56.0-src/vendor/git2/src/oid.rs     2021-10-18 13:05:54.000000000 +0200
1838 +++ rustc-1.56.0-src-git2/vendor/git2/src/oid.rs        2021-10-23 20:47:39.255788944 +0200
1839 @@ -35,7 +35,7 @@
1840                  s.len() as libc::size_t
1841              ));
1842          }
1843 -        Ok(Oid { raw: raw })
1844 +        Ok(Oid { raw })
1845      }
1846
1847      /// Parse a raw object id into an Oid structure.
1848 @@ -52,7 +52,7 @@
1849              unsafe {
1850                  try_call!(raw::git_oid_fromraw(&mut raw, bytes.as_ptr()));
1851              }
1852 -            Ok(Oid { raw: raw })
1853 +            Ok(Oid { raw })
1854          }
1855      }
1856
1857 diff -urN rustc-1.56.0-src/vendor/git2/src/opts.rs rustc-1.56.0-src-git2/vendor/git2/src/opts.rs
1858 --- rustc-1.56.0-src/vendor/git2/src/opts.rs    2021-10-18 13:05:54.000000000 +0200
1859 +++ rustc-1.56.0-src-git2/vendor/git2/src/opts.rs       2021-10-23 20:47:39.255788944 +0200
1860 @@ -3,7 +3,7 @@
1861  use std::ffi::CString;
1862
1863  use crate::util::Binding;
1864 -use crate::{call, raw, Buf, ConfigLevel, Error, IntoCString};
1865 +use crate::{raw, Buf, ConfigLevel, Error, IntoCString};
1866
1867  /// Set the search path for a level of config data. The search path applied to
1868  /// shared attributes and ignore files, too.
1869 @@ -23,11 +23,11 @@
1870      P: IntoCString,
1871  {
1872      crate::init();
1873 -    call::c_try(raw::git_libgit2_opts(
1874 +    try_call!(raw::git_libgit2_opts(
1875          raw::GIT_OPT_SET_SEARCH_PATH as libc::c_int,
1876          level as libc::c_int,
1877 -        path.into_c_string()?.as_ptr(),
1878 -    ))?;
1879 +        path.into_c_string()?.as_ptr()
1880 +    ));
1881      Ok(())
1882  }
1883
1884 @@ -42,11 +42,11 @@
1885  /// the global state.
1886  pub unsafe fn reset_search_path(level: ConfigLevel) -> Result<(), Error> {
1887      crate::init();
1888 -    call::c_try(raw::git_libgit2_opts(
1889 +    try_call!(raw::git_libgit2_opts(
1890          raw::GIT_OPT_SET_SEARCH_PATH as libc::c_int,
1891          level as libc::c_int,
1892 -        core::ptr::null::<u8>(),
1893 -    ))?;
1894 +        core::ptr::null::<u8>()
1895 +    ));
1896      Ok(())
1897  }
1898
1899 @@ -61,11 +61,11 @@
1900  pub unsafe fn get_search_path(level: ConfigLevel) -> Result<CString, Error> {
1901      crate::init();
1902      let buf = Buf::new();
1903 -    call::c_try(raw::git_libgit2_opts(
1904 +    try_call!(raw::git_libgit2_opts(
1905          raw::GIT_OPT_GET_SEARCH_PATH as libc::c_int,
1906          level as libc::c_int,
1907 -        buf.raw(),
1908 -    ))?;
1909 +        buf.raw() as *const _
1910 +    ));
1911      buf.into_c_string()
1912  }
1913
1914 diff -urN rustc-1.56.0-src/vendor/git2/src/packbuilder.rs rustc-1.56.0-src-git2/vendor/git2/src/packbuilder.rs
1915 --- rustc-1.56.0-src/vendor/git2/src/packbuilder.rs     2021-10-18 13:05:54.000000000 +0200
1916 +++ rustc-1.56.0-src-git2/vendor/git2/src/packbuilder.rs        2021-10-23 20:47:39.255788944 +0200
1917 @@ -21,7 +21,7 @@
1918  /// A builder for creating a packfile
1919  pub struct PackBuilder<'repo> {
1920      raw: *mut raw::git_packbuilder,
1921 -    progress: Option<Box<Box<ProgressCb<'repo>>>>,
1922 +    _progress: Option<Box<Box<ProgressCb<'repo>>>>,
1923      _marker: marker::PhantomData<&'repo Repository>,
1924  }
1925
1926 @@ -122,7 +122,7 @@
1927                  ptr as *mut _
1928              ));
1929          }
1930 -        self.progress = Some(progress);
1931 +        self._progress = Some(progress);
1932          Ok(())
1933      }
1934
1935 @@ -135,7 +135,7 @@
1936                  None,
1937                  ptr::null_mut()
1938              ));
1939 -            self.progress = None;
1940 +            self._progress = None;
1941          }
1942          Ok(())
1943      }
1944 @@ -174,7 +174,7 @@
1945      unsafe fn from_raw(ptr: *mut raw::git_packbuilder) -> PackBuilder<'repo> {
1946          PackBuilder {
1947              raw: ptr,
1948 -            progress: None,
1949 +            _progress: None,
1950              _marker: marker::PhantomData,
1951          }
1952      }
1953 diff -urN rustc-1.56.0-src/vendor/git2/src/panic.rs rustc-1.56.0-src-git2/vendor/git2/src/panic.rs
1954 --- rustc-1.56.0-src/vendor/git2/src/panic.rs   2021-10-18 13:05:54.000000000 +0200
1955 +++ rustc-1.56.0-src-git2/vendor/git2/src/panic.rs      2021-10-23 20:47:39.255788944 +0200
1956 @@ -24,7 +24,7 @@
1957  pub fn check() {
1958      let err = LAST_ERROR.with(|slot| slot.borrow_mut().take());
1959      if let Some(err) = err {
1960 -        panic!(err)
1961 +        std::panic::resume_unwind(err);
1962      }
1963  }
1964
1965 diff -urN rustc-1.56.0-src/vendor/git2/src/patch.rs rustc-1.56.0-src-git2/vendor/git2/src/patch.rs
1966 --- rustc-1.56.0-src/vendor/git2/src/patch.rs   2021-10-18 13:05:54.000000000 +0200
1967 +++ rustc-1.56.0-src-git2/vendor/git2/src/patch.rs      2021-10-23 20:47:39.255788944 +0200
1968 @@ -21,7 +21,7 @@
1969      type Raw = *mut raw::git_patch;
1970      unsafe fn from_raw(raw: Self::Raw) -> Self {
1971          Patch {
1972 -            raw: raw,
1973 +            raw,
1974              buffers: PhantomData,
1975          }
1976      }
1977 diff -urN rustc-1.56.0-src/vendor/git2/src/pathspec.rs rustc-1.56.0-src-git2/vendor/git2/src/pathspec.rs
1978 --- rustc-1.56.0-src/vendor/git2/src/pathspec.rs        2021-10-18 13:05:54.000000000 +0200
1979 +++ rustc-1.56.0-src-git2/vendor/git2/src/pathspec.rs   2021-10-23 20:47:39.255788944 +0200
1980 @@ -168,7 +168,7 @@
1981      type Raw = *mut raw::git_pathspec;
1982
1983      unsafe fn from_raw(raw: *mut raw::git_pathspec) -> Pathspec {
1984 -        Pathspec { raw: raw }
1985 +        Pathspec { raw }
1986      }
1987      fn raw(&self) -> *mut raw::git_pathspec {
1988          self.raw
1989 @@ -268,7 +268,7 @@
1990
1991      unsafe fn from_raw(raw: *mut raw::git_pathspec_match_list) -> PathspecMatchList<'ps> {
1992          PathspecMatchList {
1993 -            raw: raw,
1994 +            raw,
1995              _marker: marker::PhantomData,
1996          }
1997      }
1998 diff -urN rustc-1.56.0-src/vendor/git2/src/rebase.rs rustc-1.56.0-src-git2/vendor/git2/src/rebase.rs
1999 --- rustc-1.56.0-src/vendor/git2/src/rebase.rs  2021-10-18 13:05:54.000000000 +0200
2000 +++ rustc-1.56.0-src-git2/vendor/git2/src/rebase.rs     2021-10-23 20:47:39.255788944 +0200
2001 @@ -230,7 +230,7 @@
2002      type Raw = *mut raw::git_rebase;
2003      unsafe fn from_raw(raw: *mut raw::git_rebase) -> Rebase<'repo> {
2004          Rebase {
2005 -            raw: raw,
2006 +            raw,
2007              _marker: marker::PhantomData,
2008          }
2009      }
2010 @@ -324,7 +324,7 @@
2011      type Raw = *const raw::git_rebase_operation;
2012      unsafe fn from_raw(raw: *const raw::git_rebase_operation) -> RebaseOperation<'rebase> {
2013          RebaseOperation {
2014 -            raw: raw,
2015 +            raw,
2016              _marker: marker::PhantomData,
2017          }
2018      }
2019 diff -urN rustc-1.56.0-src/vendor/git2/src/reference.rs rustc-1.56.0-src-git2/vendor/git2/src/reference.rs
2020 --- rustc-1.56.0-src/vendor/git2/src/reference.rs       2021-10-18 13:05:54.000000000 +0200
2021 +++ rustc-1.56.0-src-git2/vendor/git2/src/reference.rs  2021-10-23 20:47:39.255788944 +0200
2022 @@ -387,7 +387,7 @@
2023      type Raw = *mut raw::git_reference;
2024      unsafe fn from_raw(raw: *mut raw::git_reference) -> Reference<'repo> {
2025          Reference {
2026 -            raw: raw,
2027 +            raw,
2028              _marker: marker::PhantomData,
2029          }
2030      }
2031 @@ -419,7 +419,7 @@
2032      type Raw = *mut raw::git_reference_iterator;
2033      unsafe fn from_raw(raw: *mut raw::git_reference_iterator) -> References<'repo> {
2034          References {
2035 -            raw: raw,
2036 +            raw,
2037              _marker: marker::PhantomData,
2038          }
2039      }
2040 diff -urN rustc-1.56.0-src/vendor/git2/src/reflog.rs rustc-1.56.0-src-git2/vendor/git2/src/reflog.rs
2041 --- rustc-1.56.0-src/vendor/git2/src/reflog.rs  2021-10-18 13:05:54.000000000 +0200
2042 +++ rustc-1.56.0-src-git2/vendor/git2/src/reflog.rs     2021-10-23 20:47:39.255788944 +0200
2043 @@ -103,7 +103,7 @@
2044      type Raw = *mut raw::git_reflog;
2045
2046      unsafe fn from_raw(raw: *mut raw::git_reflog) -> Reflog {
2047 -        Reflog { raw: raw }
2048 +        Reflog { raw }
2049      }
2050      fn raw(&self) -> *mut raw::git_reflog {
2051          self.raw
2052 @@ -151,7 +151,7 @@
2053
2054      unsafe fn from_raw(raw: *const raw::git_reflog_entry) -> ReflogEntry<'reflog> {
2055          ReflogEntry {
2056 -            raw: raw,
2057 +            raw,
2058              _marker: marker::PhantomData,
2059          }
2060      }
2061 diff -urN rustc-1.56.0-src/vendor/git2/src/refspec.rs rustc-1.56.0-src-git2/vendor/git2/src/refspec.rs
2062 --- rustc-1.56.0-src/vendor/git2/src/refspec.rs 2021-10-18 13:05:54.000000000 +0200
2063 +++ rustc-1.56.0-src-git2/vendor/git2/src/refspec.rs    2021-10-23 20:47:39.255788944 +0200
2064 @@ -112,7 +112,7 @@
2065
2066      unsafe fn from_raw(raw: *const raw::git_refspec) -> Refspec<'remote> {
2067          Refspec {
2068 -            raw: raw,
2069 +            raw,
2070              _marker: marker::PhantomData,
2071          }
2072      }
2073 diff -urN rustc-1.56.0-src/vendor/git2/src/remote.rs rustc-1.56.0-src-git2/vendor/git2/src/remote.rs
2074 --- rustc-1.56.0-src/vendor/git2/src/remote.rs  2021-10-18 13:05:54.000000000 +0200
2075 +++ rustc-1.56.0-src-git2/vendor/git2/src/remote.rs     2021-10-23 20:47:39.255788944 +0200
2076 @@ -1,11 +1,12 @@
2077  use libc;
2078 -use std::ffi::CString;
2079 +use raw::git_strarray;
2080  use std::marker;
2081  use std::mem;
2082  use std::ops::Range;
2083  use std::ptr;
2084  use std::slice;
2085  use std::str;
2086 +use std::{ffi::CString, os::raw::c_char};
2087
2088  use crate::string_array::StringArray;
2089  use crate::util::Binding;
2090 @@ -43,6 +44,8 @@
2091      prune: FetchPrune,
2092      update_fetchhead: bool,
2093      download_tags: AutotagOption,
2094 +    custom_headers: Vec<CString>,
2095 +    custom_headers_ptrs: Vec<*const c_char>,
2096  }
2097
2098  /// Options to control the behavior of a git push.
2099 @@ -50,6 +53,8 @@
2100      callbacks: Option<RemoteCallbacks<'cb>>,
2101      proxy: Option<ProxyOptions<'cb>>,
2102      pb_parallelism: u32,
2103 +    custom_headers: Vec<CString>,
2104 +    custom_headers_ptrs: Vec<*const c_char>,
2105  }
2106
2107  /// Holds callbacks for a connection to a `Remote`. Disconnects when dropped
2108 @@ -62,7 +67,7 @@
2109  pub fn remote_into_raw(remote: Remote<'_>) -> *mut raw::git_remote {
2110      let ret = remote.raw;
2111      mem::forget(remote);
2112 -    return ret;
2113 +    ret
2114  }
2115
2116  impl<'repo> Remote<'repo> {
2117 @@ -221,6 +226,17 @@
2118          Ok(())
2119      }
2120
2121 +    /// Cancel the operation
2122 +    ///
2123 +    /// At certain points in its operation, the network code checks whether the
2124 +    /// operation has been cancelled and if so stops the operation.
2125 +    pub fn stop(&mut self) -> Result<(), Error> {
2126 +        unsafe {
2127 +            try_call!(raw::git_remote_stop(self.raw));
2128 +        }
2129 +        Ok(())
2130 +    }
2131 +
2132      /// Get the number of refspecs for a remote
2133      pub fn refspecs(&self) -> Refspecs<'_> {
2134          let cnt = unsafe { raw::git_remote_refspec_count(&*self.raw) as usize };
2135 @@ -345,6 +361,15 @@
2136          }
2137      }
2138
2139 +    /// Prune tracking refs that are no longer present on remote
2140 +    pub fn prune(&mut self, callbacks: Option<RemoteCallbacks<'_>>) -> Result<(), Error> {
2141 +        let cbs = Box::new(callbacks.unwrap_or_else(RemoteCallbacks::new));
2142 +        unsafe {
2143 +            try_call!(raw::git_remote_prune(self.raw, &cbs.raw()));
2144 +        }
2145 +        Ok(())
2146 +    }
2147 +
2148      /// Get the remote's list of fetch refspecs
2149      pub fn fetch_refspecs(&self) -> Result<StringArray, Error> {
2150          unsafe {
2151 @@ -381,7 +406,7 @@
2152
2153      unsafe fn from_raw(raw: *mut raw::git_remote) -> Remote<'repo> {
2154          Remote {
2155 -            raw: raw,
2156 +            raw,
2157              _marker: marker::PhantomData,
2158          }
2159      }
2160 @@ -454,6 +479,8 @@
2161              prune: FetchPrune::Unspecified,
2162              update_fetchhead: true,
2163              download_tags: AutotagOption::Unspecified,
2164 +            custom_headers: Vec::new(),
2165 +            custom_headers_ptrs: Vec::new(),
2166          }
2167      }
2168
2169 @@ -491,6 +518,16 @@
2170          self.download_tags = opt;
2171          self
2172      }
2173 +
2174 +    /// Set extra headers for this fetch operation.
2175 +    pub fn custom_headers(&mut self, custom_headers: &[&str]) -> &mut Self {
2176 +        self.custom_headers = custom_headers
2177 +            .iter()
2178 +            .map(|&s| CString::new(s).unwrap())
2179 +            .collect();
2180 +        self.custom_headers_ptrs = self.custom_headers.iter().map(|s| s.as_ptr()).collect();
2181 +        self
2182 +    }
2183  }
2184
2185  impl<'cb> Binding for FetchOptions<'cb> {
2186 @@ -515,10 +552,9 @@
2187              prune: crate::call::convert(&self.prune),
2188              update_fetchhead: crate::call::convert(&self.update_fetchhead),
2189              download_tags: crate::call::convert(&self.download_tags),
2190 -            // TODO: expose this as a builder option
2191 -            custom_headers: raw::git_strarray {
2192 -                count: 0,
2193 -                strings: ptr::null_mut(),
2194 +            custom_headers: git_strarray {
2195 +                count: self.custom_headers_ptrs.len(),
2196 +                strings: self.custom_headers_ptrs.as_ptr() as *mut _,
2197              },
2198          }
2199      }
2200 @@ -537,6 +573,8 @@
2201              callbacks: None,
2202              proxy: None,
2203              pb_parallelism: 1,
2204 +            custom_headers: Vec::new(),
2205 +            custom_headers_ptrs: Vec::new(),
2206          }
2207      }
2208
2209 @@ -562,6 +600,16 @@
2210          self.pb_parallelism = parallel;
2211          self
2212      }
2213 +
2214 +    /// Set extra headers for this push operation.
2215 +    pub fn custom_headers(&mut self, custom_headers: &[&str]) -> &mut Self {
2216 +        self.custom_headers = custom_headers
2217 +            .iter()
2218 +            .map(|&s| CString::new(s).unwrap())
2219 +            .collect();
2220 +        self.custom_headers_ptrs = self.custom_headers.iter().map(|s| s.as_ptr()).collect();
2221 +        self
2222 +    }
2223  }
2224
2225  impl<'cb> Binding for PushOptions<'cb> {
2226 @@ -584,10 +632,9 @@
2227                  .map(|m| m.raw())
2228                  .unwrap_or_else(|| ProxyOptions::new().raw()),
2229              pb_parallelism: self.pb_parallelism as libc::c_uint,
2230 -            // TODO: expose this as a builder option
2231 -            custom_headers: raw::git_strarray {
2232 -                count: 0,
2233 -                strings: ptr::null_mut(),
2234 +            custom_headers: git_strarray {
2235 +                count: self.custom_headers_ptrs.len(),
2236 +                strings: self.custom_headers_ptrs.as_ptr() as *mut _,
2237              },
2238          }
2239      }
2240 @@ -614,6 +661,11 @@
2241      pub fn default_branch(&self) -> Result<Buf, Error> {
2242          self.remote.default_branch()
2243      }
2244 +
2245 +    /// access remote bound to this connection
2246 +    pub fn remote(&mut self) -> &mut Remote<'repo> {
2247 +        self.remote
2248 +    }
2249  }
2250
2251  impl<'repo, 'connection, 'cb> Drop for RemoteConnection<'repo, 'connection, 'cb> {
2252 @@ -636,7 +688,7 @@
2253          drop(repo);
2254
2255          let repo = t!(Repository::init(td.path()));
2256 -        let origin = t!(repo.find_remote("origin"));
2257 +        let mut origin = t!(repo.find_remote("origin"));
2258          assert_eq!(origin.name(), Some("origin"));
2259          assert_eq!(origin.url(), Some("/path/to/nowhere"));
2260          assert_eq!(origin.pushurl(), None);
2261 @@ -646,6 +698,8 @@
2262
2263          let stats = origin.stats();
2264          assert_eq!(stats.total_objects(), 0);
2265 +
2266 +        t!(origin.stop());
2267      }
2268
2269      #[test]
2270 @@ -847,4 +901,46 @@
2271          let commit = repo.find_commit(commit).unwrap();
2272          assert_eq!(commit.message(), Some("initial"));
2273      }
2274 +
2275 +    #[test]
2276 +    fn prune() {
2277 +        let (td, remote_repo) = crate::test::repo_init();
2278 +        let oid = remote_repo.head().unwrap().target().unwrap();
2279 +        let commit = remote_repo.find_commit(oid).unwrap();
2280 +        remote_repo.branch("stale", &commit, true).unwrap();
2281 +
2282 +        let td2 = TempDir::new().unwrap();
2283 +        let url = crate::test::path2url(&td.path());
2284 +        let repo = Repository::clone(&url, &td2).unwrap();
2285 +
2286 +        fn assert_branch_count(repo: &Repository, count: usize) {
2287 +            assert_eq!(
2288 +                repo.branches(Some(crate::BranchType::Remote))
2289 +                    .unwrap()
2290 +                    .filter(|b| b.as_ref().unwrap().0.name().unwrap() == Some("origin/stale"))
2291 +                    .count(),
2292 +                count,
2293 +            );
2294 +        }
2295 +
2296 +        assert_branch_count(&repo, 1);
2297 +
2298 +        // delete `stale` branch on remote repo
2299 +        let mut stale_branch = remote_repo
2300 +            .find_branch("stale", crate::BranchType::Local)
2301 +            .unwrap();
2302 +        stale_branch.delete().unwrap();
2303 +
2304 +        // prune
2305 +        let mut remote = repo.find_remote("origin").unwrap();
2306 +        remote.connect(Direction::Push).unwrap();
2307 +        let mut callbacks = RemoteCallbacks::new();
2308 +        callbacks.update_tips(|refname, _a, b| {
2309 +            assert_eq!(refname, "refs/remotes/origin/stale");
2310 +            assert!(b.is_zero());
2311 +            true
2312 +        });
2313 +        remote.prune(Some(callbacks)).unwrap();
2314 +        assert_branch_count(&repo, 0);
2315 +    }
2316  }
2317 diff -urN rustc-1.56.0-src/vendor/git2/src/repo.rs rustc-1.56.0-src-git2/vendor/git2/src/repo.rs
2318 --- rustc-1.56.0-src/vendor/git2/src/repo.rs    2021-10-18 13:05:54.000000000 +0200
2319 +++ rustc-1.56.0-src-git2/vendor/git2/src/repo.rs       2021-10-23 20:47:39.255788944 +0200
2320 @@ -19,19 +19,82 @@
2321  use crate::worktree::{Worktree, WorktreeAddOptions};
2322  use crate::CherrypickOptions;
2323  use crate::RevertOptions;
2324 +use crate::{mailmap::Mailmap, panic};
2325  use crate::{
2326      raw, AttrCheckFlags, Buf, Error, Object, Remote, RepositoryOpenFlags, RepositoryState, Revspec,
2327      StashFlags,
2328  };
2329  use crate::{
2330 -    AnnotatedCommit, MergeAnalysis, MergeOptions, MergePreference, SubmoduleIgnore, SubmoduleStatus,
2331 +    AnnotatedCommit, MergeAnalysis, MergeOptions, MergePreference, SubmoduleIgnore,
2332 +    SubmoduleStatus, SubmoduleUpdate,
2333  };
2334  use crate::{ApplyLocation, ApplyOptions, Rebase, RebaseOptions};
2335  use crate::{Blame, BlameOptions, Reference, References, ResetType, Signature, Submodule};
2336  use crate::{Blob, BlobWriter, Branch, BranchType, Branches, Commit, Config, Index, Oid, Tree};
2337  use crate::{Describe, IntoCString, Reflog, RepositoryInitMode, RevparseMode};
2338  use crate::{DescribeOptions, Diff, DiffOptions, Odb, PackBuilder, TreeBuilder};
2339 -use crate::{Note, Notes, ObjectType, Revwalk, Status, StatusOptions, Statuses, Tag};
2340 +use crate::{Note, Notes, ObjectType, Revwalk, Status, StatusOptions, Statuses, Tag, Transaction};
2341 +
2342 +type MergeheadForeachCb<'a> = dyn FnMut(&Oid) -> bool + 'a;
2343 +type FetchheadForeachCb<'a> = dyn FnMut(&str, &[u8], &Oid, bool) -> bool + 'a;
2344 +
2345 +struct FetchheadForeachCbData<'a> {
2346 +    callback: &'a mut FetchheadForeachCb<'a>,
2347 +}
2348 +
2349 +struct MergeheadForeachCbData<'a> {
2350 +    callback: &'a mut MergeheadForeachCb<'a>,
2351 +}
2352 +
2353 +extern "C" fn mergehead_foreach_cb(oid: *const raw::git_oid, payload: *mut c_void) -> c_int {
2354 +    panic::wrap(|| unsafe {
2355 +        let data = &mut *(payload as *mut MergeheadForeachCbData<'_>);
2356 +        let res = {
2357 +            let callback = &mut data.callback;
2358 +            callback(&Binding::from_raw(oid))
2359 +        };
2360 +
2361 +        if res {
2362 +            0
2363 +        } else {
2364 +            1
2365 +        }
2366 +    })
2367 +    .unwrap_or(1)
2368 +}
2369 +
2370 +extern "C" fn fetchhead_foreach_cb(
2371 +    ref_name: *const c_char,
2372 +    remote_url: *const c_char,
2373 +    oid: *const raw::git_oid,
2374 +    is_merge: c_uint,
2375 +    payload: *mut c_void,
2376 +) -> c_int {
2377 +    panic::wrap(|| unsafe {
2378 +        let data = &mut *(payload as *mut FetchheadForeachCbData<'_>);
2379 +        let res = {
2380 +            let callback = &mut data.callback;
2381 +
2382 +            assert!(!ref_name.is_null());
2383 +            assert!(!remote_url.is_null());
2384 +            assert!(!oid.is_null());
2385 +
2386 +            let ref_name = str::from_utf8(CStr::from_ptr(ref_name).to_bytes()).unwrap();
2387 +            let remote_url = CStr::from_ptr(remote_url).to_bytes();
2388 +            let oid = Binding::from_raw(oid);
2389 +            let is_merge = is_merge == 1;
2390 +
2391 +            callback(&ref_name, remote_url, &oid, is_merge)
2392 +        };
2393 +
2394 +        if res {
2395 +            0
2396 +        } else {
2397 +            1
2398 +        }
2399 +    })
2400 +    .unwrap_or(1)
2401 +}
2402
2403  /// An owned git repository, representing all state associated with the
2404  /// underlying filesystem.
2405 @@ -952,6 +1015,14 @@
2406      }
2407
2408      /// Get the value of a git attribute for a path as a string.
2409 +    ///
2410 +    /// This function will return a special string if the attribute is set to a special value.
2411 +    /// Interpreting the special string is discouraged. You should always use
2412 +    /// [`AttrValue::from_string`](crate::AttrValue::from_string) to interpret the return value
2413 +    /// and avoid the special string.
2414 +    ///
2415 +    /// As such, the return type of this function will probably be changed in the next major version
2416 +    /// to prevent interpreting the returned string without checking whether it's special.
2417      pub fn get_attr(
2418          &self,
2419          path: &Path,
2420 @@ -964,6 +1035,14 @@
2421      }
2422
2423      /// Get the value of a git attribute for a path as a byte slice.
2424 +    ///
2425 +    /// This function will return a special byte slice if the attribute is set to a special value.
2426 +    /// Interpreting the special byte slice is discouraged. You should always use
2427 +    /// [`AttrValue::from_bytes`](crate::AttrValue::from_bytes) to interpret the return value and
2428 +    /// avoid the special string.
2429 +    ///
2430 +    /// As such, the return type of this function will probably be changed in the next major version
2431 +    /// to prevent interpreting the returned byte slice without checking whether it's special.
2432      pub fn get_attr_bytes(
2433          &self,
2434          path: &Path,
2435 @@ -1619,6 +1698,62 @@
2436          Ok(SubmoduleStatus::from_bits_truncate(ret as u32))
2437      }
2438
2439 +    /// Set the ignore rule for the submodule in the configuration
2440 +    ///
2441 +    /// This does not affect any currently-loaded instances.
2442 +    pub fn submodule_set_ignore(
2443 +        &mut self,
2444 +        name: &str,
2445 +        ignore: SubmoduleIgnore,
2446 +    ) -> Result<(), Error> {
2447 +        let name = CString::new(name)?;
2448 +        unsafe {
2449 +            try_call!(raw::git_submodule_set_ignore(self.raw(), name, ignore));
2450 +        }
2451 +        Ok(())
2452 +    }
2453 +
2454 +    /// Set the update rule for the submodule in the configuration
2455 +    ///
2456 +    /// This setting won't affect any existing instances.
2457 +    pub fn submodule_set_update(
2458 +        &mut self,
2459 +        name: &str,
2460 +        update: SubmoduleUpdate,
2461 +    ) -> Result<(), Error> {
2462 +        let name = CString::new(name)?;
2463 +        unsafe {
2464 +            try_call!(raw::git_submodule_set_update(self.raw(), name, update));
2465 +        }
2466 +        Ok(())
2467 +    }
2468 +
2469 +    /// Set the URL for the submodule in the configuration
2470 +    ///
2471 +    /// After calling this, you may wish to call [`Submodule::sync`] to write
2472 +    /// the changes to the checked out submodule repository.
2473 +    pub fn submodule_set_url(&mut self, name: &str, url: &str) -> Result<(), Error> {
2474 +        let name = CString::new(name)?;
2475 +        let url = CString::new(url)?;
2476 +        unsafe {
2477 +            try_call!(raw::git_submodule_set_url(self.raw(), name, url));
2478 +        }
2479 +        Ok(())
2480 +    }
2481 +
2482 +    /// Set the branch for the submodule in the configuration
2483 +    ///
2484 +    /// After calling this, you may wish to call [`Submodule::sync`] to write
2485 +    /// the changes to the checked out submodule repository.
2486 +    pub fn submodule_set_branch(&mut self, name: &str, branch_name: &str) -> Result<(), Error> {
2487 +        let name = CString::new(name)?;
2488 +        let branch_name = CString::new(branch_name)?;
2489 +        unsafe {
2490 +            try_call!(raw::git_submodule_set_branch(self.raw(), name, branch_name));
2491 +        }
2492 +        Ok(())
2493 +    }
2494 +
2495      /// Lookup a reference to one of the objects in a repository.
2496      pub fn find_tree(&self, oid: Oid) -> Result<Tree<'_>, Error> {
2497          let mut raw = ptr::null_mut();
2498 @@ -2708,7 +2843,7 @@
2499          let raw_opts = options.map(|o| o.raw());
2500          let ptr_raw_opts = match raw_opts.as_ref() {
2501              Some(v) => v,
2502 -            None => 0 as *const _,
2503 +            None => std::ptr::null(),
2504          };
2505          unsafe {
2506              try_call!(raw::git_cherrypick(self.raw(), commit.raw(), ptr_raw_opts));
2507 @@ -2794,6 +2929,26 @@
2508          }
2509      }
2510
2511 +    /// Apply a Diff to the provided tree, and return the resulting Index.
2512 +    pub fn apply_to_tree(
2513 +        &self,
2514 +        tree: &Tree<'_>,
2515 +        diff: &Diff<'_>,
2516 +        options: Option<&mut ApplyOptions<'_>>,
2517 +    ) -> Result<Index, Error> {
2518 +        let mut ret = ptr::null_mut();
2519 +        unsafe {
2520 +            try_call!(raw::git_apply_to_tree(
2521 +                &mut ret,
2522 +                self.raw,
2523 +                tree.raw(),
2524 +                diff.raw(),
2525 +                options.map(|s| s.raw()).unwrap_or(ptr::null())
2526 +            ));
2527 +            Ok(Binding::from_raw(ret))
2528 +        }
2529 +    }
2530 +
2531      /// Reverts the given commit, producing changes in the index and working directory.
2532      pub fn revert(
2533          &self,
2534 @@ -2880,6 +3035,70 @@
2535              Ok(Binding::from_raw(raw))
2536          }
2537      }
2538 +
2539 +    /// Create a new transaction
2540 +    pub fn transaction<'a>(&'a self) -> Result<Transaction<'a>, Error> {
2541 +        let mut raw = ptr::null_mut();
2542 +        unsafe {
2543 +            try_call!(raw::git_transaction_new(&mut raw, self.raw));
2544 +            Ok(Binding::from_raw(raw))
2545 +        }
2546 +    }
2547 +
2548 +    /// Gets this repository's mailmap.
2549 +    pub fn mailmap(&self) -> Result<Mailmap, Error> {
2550 +        let mut ret = ptr::null_mut();
2551 +        unsafe {
2552 +            try_call!(raw::git_mailmap_from_repository(&mut ret, self.raw));
2553 +            Ok(Binding::from_raw(ret))
2554 +        }
2555 +    }
2556 +
2557 +    ///  If a merge is in progress, invoke 'callback' for each commit ID in the
2558 +    ///  MERGE_HEAD file.
2559 +    pub fn mergehead_foreach<C>(&mut self, mut callback: C) -> Result<(), Error>
2560 +    where
2561 +        C: FnMut(&Oid) -> bool,
2562 +    {
2563 +        unsafe {
2564 +            let mut data = MergeheadForeachCbData {
2565 +                callback: &mut callback,
2566 +            };
2567 +            let cb: raw::git_repository_mergehead_foreach_cb = Some(mergehead_foreach_cb);
2568 +            try_call!(raw::git_repository_mergehead_foreach(
2569 +                self.raw(),
2570 +                cb,
2571 +                &mut data as *mut _ as *mut _
2572 +            ));
2573 +            Ok(())
2574 +        }
2575 +    }
2576 +
2577 +    /// Invoke 'callback' for each entry in the given FETCH_HEAD file.
2578 +    ///
2579 +    /// `callback` will be called with with following arguments:
2580 +    ///
2581 +    /// - `&str`: the reference name
2582 +    /// - `&[u8]`: the remote url
2583 +    /// - `&Oid`: the reference target OID
2584 +    /// - `bool`: was the reference the result of a merge
2585 +    pub fn fetchhead_foreach<C>(&self, mut callback: C) -> Result<(), Error>
2586 +    where
2587 +        C: FnMut(&str, &[u8], &Oid, bool) -> bool,
2588 +    {
2589 +        unsafe {
2590 +            let mut data = FetchheadForeachCbData {
2591 +                callback: &mut callback,
2592 +            };
2593 +            let cb: raw::git_repository_fetchhead_foreach_cb = Some(fetchhead_foreach_cb);
2594 +            try_call!(raw::git_repository_fetchhead_foreach(
2595 +                self.raw(),
2596 +                cb,
2597 +                &mut data as *mut _ as *mut _
2598 +            ));
2599 +            Ok(())
2600 +        }
2601 +    }
2602  }
2603
2604  impl Binding for Repository {
2605 @@ -3062,7 +3281,9 @@
2606  mod tests {
2607      use crate::build::CheckoutBuilder;
2608      use crate::CherrypickOptions;
2609 -    use crate::{ObjectType, Oid, Repository, ResetType};
2610 +    use crate::{
2611 +        ObjectType, Oid, Repository, ResetType, Signature, SubmoduleIgnore, SubmoduleUpdate,
2612 +    };
2613      use std::ffi::OsStr;
2614      use std::fs;
2615      use std::path::Path;
2616 @@ -3705,4 +3926,143 @@
2617
2618          Ok(())
2619      }
2620 +
2621 +    #[test]
2622 +    fn smoke_submodule_set() -> Result<(), crate::Error> {
2623 +        let (td1, _repo) = crate::test::repo_init();
2624 +        let (td2, mut repo2) = crate::test::repo_init();
2625 +        let url = crate::test::path2url(td1.path());
2626 +        let name = "bar";
2627 +        {
2628 +            let mut s = repo2.submodule(&url, Path::new(name), true)?;
2629 +            fs::remove_dir_all(td2.path().join("bar")).unwrap();
2630 +            Repository::clone(&url, td2.path().join("bar"))?;
2631 +            s.add_to_index(false)?;
2632 +            s.add_finalize()?;
2633 +        }
2634 +
2635 +        // update strategy
2636 +        repo2.submodule_set_update(name, SubmoduleUpdate::None)?;
2637 +        assert!(matches!(
2638 +            repo2.find_submodule(name)?.update_strategy(),
2639 +            SubmoduleUpdate::None
2640 +        ));
2641 +        repo2.submodule_set_update(name, SubmoduleUpdate::Rebase)?;
2642 +        assert!(matches!(
2643 +            repo2.find_submodule(name)?.update_strategy(),
2644 +            SubmoduleUpdate::Rebase
2645 +        ));
2646 +
2647 +        // ignore rule
2648 +        repo2.submodule_set_ignore(name, SubmoduleIgnore::Untracked)?;
2649 +        assert!(matches!(
2650 +            repo2.find_submodule(name)?.ignore_rule(),
2651 +            SubmoduleIgnore::Untracked
2652 +        ));
2653 +        repo2.submodule_set_ignore(name, SubmoduleIgnore::Dirty)?;
2654 +        assert!(matches!(
2655 +            repo2.find_submodule(name)?.ignore_rule(),
2656 +            SubmoduleIgnore::Dirty
2657 +        ));
2658 +
2659 +        // url
2660 +        repo2.submodule_set_url(name, "fake-url")?;
2661 +        assert_eq!(repo2.find_submodule(name)?.url(), Some("fake-url"));
2662 +
2663 +        // branch
2664 +        repo2.submodule_set_branch(name, "fake-branch")?;
2665 +        assert_eq!(repo2.find_submodule(name)?.branch(), Some("fake-branch"));
2666 +
2667 +        Ok(())
2668 +    }
2669 +
2670 +    #[test]
2671 +    fn smoke_mailmap_from_repository() {
2672 +        let (_td, repo) = crate::test::repo_init();
2673 +
2674 +        let commit = {
2675 +            let head = t!(repo.head()).target().unwrap();
2676 +            t!(repo.find_commit(head))
2677 +        };
2678 +
2679 +        // This is our baseline for HEAD.
2680 +        let author = commit.author();
2681 +        let committer = commit.committer();
2682 +        assert_eq!(author.name(), Some("name"));
2683 +        assert_eq!(author.email(), Some("email"));
2684 +        assert_eq!(committer.name(), Some("name"));
2685 +        assert_eq!(committer.email(), Some("email"));
2686 +
2687 +        // There is no .mailmap file in the test repo so all signature identities are equal.
2688 +        let mailmap = t!(repo.mailmap());
2689 +        let mailmapped_author = t!(commit.author_with_mailmap(&mailmap));
2690 +        let mailmapped_committer = t!(commit.committer_with_mailmap(&mailmap));
2691 +        assert_eq!(mailmapped_author.name(), author.name());
2692 +        assert_eq!(mailmapped_author.email(), author.email());
2693 +        assert_eq!(mailmapped_committer.name(), committer.name());
2694 +        assert_eq!(mailmapped_committer.email(), committer.email());
2695 +
2696 +        let commit = {
2697 +            // - Add a .mailmap file to the repository.
2698 +            // - Commit with a signature identity different from the author's.
2699 +            // - Include entries for both author and committer to prove we call
2700 +            //   the right raw functions.
2701 +            let mailmap_file = Path::new(".mailmap");
2702 +            let p = Path::new(repo.workdir().unwrap()).join(&mailmap_file);
2703 +            t!(fs::write(
2704 +                p,
2705 +                r#"
2706 +Author Name <author.proper@email> name <email>
2707 +Committer Name <committer.proper@email> <committer@email>"#,
2708 +            ));
2709 +            let mut index = t!(repo.index());
2710 +            t!(index.add_path(&mailmap_file));
2711 +            let id_mailmap = t!(index.write_tree());
2712 +            let tree_mailmap = t!(repo.find_tree(id_mailmap));
2713 +
2714 +            let head = t!(repo.commit(
2715 +                Some("HEAD"),
2716 +                &author,
2717 +                t!(&Signature::now("committer", "committer@email")),
2718 +                "Add mailmap",
2719 +                &tree_mailmap,
2720 +                &[&commit],
2721 +            ));
2722 +            t!(repo.find_commit(head))
2723 +        };
2724 +
2725 +        // Sanity check that we're working with the right commit and that its
2726 +        // author and committer identities differ.
2727 +        let author = commit.author();
2728 +        let committer = commit.committer();
2729 +        assert_ne!(author.name(), committer.name());
2730 +        assert_ne!(author.email(), committer.email());
2731 +        assert_eq!(author.name(), Some("name"));
2732 +        assert_eq!(author.email(), Some("email"));
2733 +        assert_eq!(committer.name(), Some("committer"));
2734 +        assert_eq!(committer.email(), Some("committer@email"));
2735 +
2736 +        // Fetch the newly added .mailmap from the repository.
2737 +        let mailmap = t!(repo.mailmap());
2738 +        let mailmapped_author = t!(commit.author_with_mailmap(&mailmap));
2739 +        let mailmapped_committer = t!(commit.committer_with_mailmap(&mailmap));
2740 +
2741 +        let mm_resolve_author = t!(mailmap.resolve_signature(&author));
2742 +        let mm_resolve_committer = t!(mailmap.resolve_signature(&committer));
2743 +
2744 +        // Mailmap Signature lifetime is independent of Commit lifetime.
2745 +        drop(author);
2746 +        drop(committer);
2747 +        drop(commit);
2748 +
2749 +        // author_with_mailmap() + committer_with_mailmap() work
2750 +        assert_eq!(mailmapped_author.name(), Some("Author Name"));
2751 +        assert_eq!(mailmapped_author.email(), Some("author.proper@email"));
2752 +        assert_eq!(mailmapped_committer.name(), Some("Committer Name"));
2753 +        assert_eq!(mailmapped_committer.email(), Some("committer.proper@email"));
2754 +
2755 +        // resolve_signature() works
2756 +        assert_eq!(mm_resolve_author.email(), mailmapped_author.email());
2757 +        assert_eq!(mm_resolve_committer.email(), mailmapped_committer.email());
2758 +    }
2759  }
2760 diff -urN rustc-1.56.0-src/vendor/git2/src/revspec.rs rustc-1.56.0-src-git2/vendor/git2/src/revspec.rs
2761 --- rustc-1.56.0-src/vendor/git2/src/revspec.rs 2021-10-18 13:05:54.000000000 +0200
2762 +++ rustc-1.56.0-src-git2/vendor/git2/src/revspec.rs    2021-10-23 20:47:39.255788944 +0200
2763 @@ -14,11 +14,7 @@
2764          to: Option<Object<'repo>>,
2765          mode: RevparseMode,
2766      ) -> Revspec<'repo> {
2767 -        Revspec {
2768 -            from: from,
2769 -            to: to,
2770 -            mode: mode,
2771 -        }
2772 +        Revspec { from, to, mode }
2773      }
2774
2775      /// Access the `from` range of this revspec.
2776 diff -urN rustc-1.56.0-src/vendor/git2/src/revwalk.rs rustc-1.56.0-src-git2/vendor/git2/src/revwalk.rs
2777 --- rustc-1.56.0-src/vendor/git2/src/revwalk.rs 2021-10-18 13:05:54.000000000 +0200
2778 +++ rustc-1.56.0-src-git2/vendor/git2/src/revwalk.rs    2021-10-23 20:47:39.255788944 +0200
2779 @@ -1,9 +1,9 @@
2780 -use libc::c_uint;
2781 +use libc::{c_int, c_uint, c_void};
2782  use std::ffi::CString;
2783  use std::marker;
2784
2785  use crate::util::Binding;
2786 -use crate::{raw, Error, Oid, Repository, Sort};
2787 +use crate::{panic, raw, Error, Oid, Repository, Sort};
2788
2789  /// A revwalk allows traversal of the commit graph defined by including one or
2790  /// more leaves and excluding one or more roots.
2791 @@ -12,6 +12,40 @@
2792      _marker: marker::PhantomData<&'repo Repository>,
2793  }
2794
2795 +/// A `Revwalk` with an assiciated "hide callback", see `with_hide_callback`
2796 +pub struct RevwalkWithHideCb<'repo, 'cb, C>
2797 +where
2798 +    C: FnMut(Oid) -> bool,
2799 +{
2800 +    revwalk: Revwalk<'repo>,
2801 +    _marker: marker::PhantomData<&'cb C>,
2802 +}
2803 +
2804 +extern "C" fn revwalk_hide_cb<C>(commit_id: *const raw::git_oid, payload: *mut c_void) -> c_int
2805 +where
2806 +    C: FnMut(Oid) -> bool,
2807 +{
2808 +    panic::wrap(|| unsafe {
2809 +        let hide_cb = payload as *mut C;
2810 +        if (*hide_cb)(Oid::from_raw(commit_id)) {
2811 +            1
2812 +        } else {
2813 +            0
2814 +        }
2815 +    })
2816 +    .unwrap_or(-1)
2817 +}
2818 +
2819 +impl<'repo, 'cb, C: FnMut(Oid) -> bool> RevwalkWithHideCb<'repo, 'cb, C> {
2820 +    /// Consumes the `RevwalkWithHideCb` and returns the contained `Revwalk`.
2821 +    ///
2822 +    /// Note that this will reset the `Revwalk`.
2823 +    pub fn into_inner(mut self) -> Result<Revwalk<'repo>, Error> {
2824 +        self.revwalk.reset()?;
2825 +        Ok(self.revwalk)
2826 +    }
2827 +}
2828 +
2829  impl<'repo> Revwalk<'repo> {
2830      /// Reset a revwalk to allow re-configuring it.
2831      ///
2832 @@ -119,6 +153,29 @@
2833          Ok(())
2834      }
2835
2836 +    /// Hide all commits for which the callback returns true from
2837 +    /// the walk.
2838 +    pub fn with_hide_callback<'cb, C>(
2839 +        self,
2840 +        callback: &'cb C,
2841 +    ) -> Result<RevwalkWithHideCb<'repo, 'cb, C>, Error>
2842 +    where
2843 +        C: FnMut(Oid) -> bool,
2844 +    {
2845 +        let r = RevwalkWithHideCb {
2846 +            revwalk: self,
2847 +            _marker: marker::PhantomData,
2848 +        };
2849 +        unsafe {
2850 +            raw::git_revwalk_add_hide_cb(
2851 +                r.revwalk.raw(),
2852 +                Some(revwalk_hide_cb::<C>),
2853 +                callback as *const _ as *mut c_void,
2854 +            );
2855 +        };
2856 +        Ok(r)
2857 +    }
2858 +
2859      /// Hide the repository's HEAD
2860      ///
2861      /// For more information, see `hide`.
2862 @@ -163,7 +220,7 @@
2863      type Raw = *mut raw::git_revwalk;
2864      unsafe fn from_raw(raw: *mut raw::git_revwalk) -> Revwalk<'repo> {
2865          Revwalk {
2866 -            raw: raw,
2867 +            raw,
2868              _marker: marker::PhantomData,
2869          }
2870      }
2871 @@ -191,6 +248,15 @@
2872      }
2873  }
2874
2875 +impl<'repo, 'cb, C: FnMut(Oid) -> bool> Iterator for RevwalkWithHideCb<'repo, 'cb, C> {
2876 +    type Item = Result<Oid, Error>;
2877 +    fn next(&mut self) -> Option<Result<Oid, Error>> {
2878 +        let out = self.revwalk.next();
2879 +        crate::panic::check();
2880 +        out
2881 +    }
2882 +}
2883 +
2884  #[cfg(test)]
2885  mod tests {
2886      #[test]
2887 @@ -216,4 +282,35 @@
2888          walk.hide_head().unwrap();
2889          assert_eq!(walk.by_ref().count(), 0);
2890      }
2891 +
2892 +    #[test]
2893 +    fn smoke_hide_cb() {
2894 +        let (_td, repo) = crate::test::repo_init();
2895 +        let head = repo.head().unwrap();
2896 +        let target = head.target().unwrap();
2897 +
2898 +        let mut walk = repo.revwalk().unwrap();
2899 +        walk.push(target).unwrap();
2900 +
2901 +        let oids: Vec<crate::Oid> = walk.by_ref().collect::<Result<Vec<_>, _>>().unwrap();
2902 +
2903 +        assert_eq!(oids.len(), 1);
2904 +        assert_eq!(oids[0], target);
2905 +
2906 +        walk.reset().unwrap();
2907 +        walk.push_head().unwrap();
2908 +        assert_eq!(walk.by_ref().count(), 1);
2909 +
2910 +        walk.reset().unwrap();
2911 +        walk.push_head().unwrap();
2912 +
2913 +        let hide_cb = |oid| oid == target;
2914 +        let mut walk = walk.with_hide_callback(&hide_cb).unwrap();
2915 +
2916 +        assert_eq!(walk.by_ref().count(), 0);
2917 +
2918 +        let mut walk = walk.into_inner().unwrap();
2919 +        walk.push_head().unwrap();
2920 +        assert_eq!(walk.by_ref().count(), 1);
2921 +    }
2922  }
2923 diff -urN rustc-1.56.0-src/vendor/git2/src/signature.rs rustc-1.56.0-src-git2/vendor/git2/src/signature.rs
2924 --- rustc-1.56.0-src/vendor/git2/src/signature.rs       2021-10-18 13:05:54.000000000 +0200
2925 +++ rustc-1.56.0-src-git2/vendor/git2/src/signature.rs  2021-10-23 20:47:39.255788944 +0200
2926 @@ -105,7 +105,7 @@
2927      type Raw = *mut raw::git_signature;
2928      unsafe fn from_raw(raw: *mut raw::git_signature) -> Signature<'a> {
2929          Signature {
2930 -            raw: raw,
2931 +            raw,
2932              _marker: marker::PhantomData,
2933              owned: true,
2934          }
2935 diff -urN rustc-1.56.0-src/vendor/git2/src/status.rs rustc-1.56.0-src-git2/vendor/git2/src/status.rs
2936 --- rustc-1.56.0-src/vendor/git2/src/status.rs  2021-10-18 13:05:54.000000000 +0200
2937 +++ rustc-1.56.0-src-git2/vendor/git2/src/status.rs     2021-10-23 20:47:39.255788944 +0200
2938 @@ -72,7 +72,7 @@
2939              let r = raw::git_status_init_options(&mut raw, raw::GIT_STATUS_OPTIONS_VERSION);
2940              assert_eq!(r, 0);
2941              StatusOptions {
2942 -                raw: raw,
2943 +                raw,
2944                  pathspec: Vec::new(),
2945                  ptrs: Vec::new(),
2946              }
2947 @@ -264,7 +264,7 @@
2948      type Raw = *mut raw::git_status_list;
2949      unsafe fn from_raw(raw: *mut raw::git_status_list) -> Statuses<'repo> {
2950          Statuses {
2951 -            raw: raw,
2952 +            raw,
2953              _marker: marker::PhantomData,
2954          }
2955      }
2956 @@ -340,7 +340,7 @@
2957
2958      unsafe fn from_raw(raw: *const raw::git_status_entry) -> StatusEntry<'statuses> {
2959          StatusEntry {
2960 -            raw: raw,
2961 +            raw,
2962              _marker: marker::PhantomData,
2963          }
2964      }
2965 diff -urN rustc-1.56.0-src/vendor/git2/src/string_array.rs rustc-1.56.0-src-git2/vendor/git2/src/string_array.rs
2966 --- rustc-1.56.0-src/vendor/git2/src/string_array.rs    2021-10-18 13:05:54.000000000 +0200
2967 +++ rustc-1.56.0-src-git2/vendor/git2/src/string_array.rs       2021-10-23 20:47:39.255788944 +0200
2968 @@ -79,7 +79,7 @@
2969  impl Binding for StringArray {
2970      type Raw = raw::git_strarray;
2971      unsafe fn from_raw(raw: raw::git_strarray) -> StringArray {
2972 -        StringArray { raw: raw }
2973 +        StringArray { raw }
2974      }
2975      fn raw(&self) -> raw::git_strarray {
2976          self.raw
2977 diff -urN rustc-1.56.0-src/vendor/git2/src/submodule.rs rustc-1.56.0-src-git2/vendor/git2/src/submodule.rs
2978 --- rustc-1.56.0-src/vendor/git2/src/submodule.rs       2021-10-18 13:05:54.000000000 +0200
2979 +++ rustc-1.56.0-src-git2/vendor/git2/src/submodule.rs  2021-10-23 20:47:39.255788944 +0200
2980 @@ -5,8 +5,8 @@
2981  use std::ptr;
2982  use std::str;
2983
2984 -use crate::build::CheckoutBuilder;
2985  use crate::util::{self, Binding};
2986 +use crate::{build::CheckoutBuilder, SubmoduleIgnore, SubmoduleUpdate};
2987  use crate::{raw, Error, FetchOptions, Oid, Repository};
2988
2989  /// A structure to represent a git [submodule][1]
2990 @@ -113,6 +113,16 @@
2991          unsafe { Binding::from_raw_opt(raw::git_submodule_wd_id(self.raw)) }
2992      }
2993
2994 +    /// Get the ignore rule that will be used for the submodule.
2995 +    pub fn ignore_rule(&self) -> SubmoduleIgnore {
2996 +        SubmoduleIgnore::from_raw(unsafe { raw::git_submodule_ignore(self.raw) })
2997 +    }
2998 +
2999 +    /// Get the update rule that will be used for the submodule.
3000 +    pub fn update_strategy(&self) -> SubmoduleUpdate {
3001 +        SubmoduleUpdate::from_raw(unsafe { raw::git_submodule_update_strategy(self.raw) })
3002 +    }
3003 +
3004      /// Copy submodule info into ".git/config" file.
3005      ///
3006      /// Just like "git submodule init", this copies information about the
3007 @@ -223,7 +233,7 @@
3008      type Raw = *mut raw::git_submodule;
3009      unsafe fn from_raw(raw: *mut raw::git_submodule) -> Submodule<'repo> {
3010          Submodule {
3011 -            raw: raw,
3012 +            raw,
3013              _marker: marker::PhantomData,
3014          }
3015      }
3016 diff -urN rustc-1.56.0-src/vendor/git2/src/tag.rs rustc-1.56.0-src-git2/vendor/git2/src/tag.rs
3017 --- rustc-1.56.0-src/vendor/git2/src/tag.rs     2021-10-18 13:05:54.000000000 +0200
3018 +++ rustc-1.56.0-src-git2/vendor/git2/src/tag.rs        2021-10-23 20:47:39.255788944 +0200
3019 @@ -86,7 +86,7 @@
3020          unsafe { Binding::from_raw(raw::git_tag_target_id(&*self.raw)) }
3021      }
3022
3023 -    /// Get the OID of the tagged object of a tag
3024 +    /// Get the ObjectType of the tagged object of a tag
3025      pub fn target_type(&self) -> Option<ObjectType> {
3026          unsafe { ObjectType::from_raw(raw::git_tag_target_type(&*self.raw)) }
3027      }
3028 @@ -118,7 +118,7 @@
3029      type Raw = *mut raw::git_tag;
3030      unsafe fn from_raw(raw: *mut raw::git_tag) -> Tag<'repo> {
3031          Tag {
3032 -            raw: raw,
3033 +            raw,
3034              _marker: marker::PhantomData,
3035          }
3036      }
3037 diff -urN rustc-1.56.0-src/vendor/git2/src/time.rs rustc-1.56.0-src-git2/vendor/git2/src/time.rs
3038 --- rustc-1.56.0-src/vendor/git2/src/time.rs    2021-10-18 13:05:54.000000000 +0200
3039 +++ rustc-1.56.0-src-git2/vendor/git2/src/time.rs       2021-10-23 20:47:39.259122276 +0200
3040 @@ -61,7 +61,7 @@
3041  impl Binding for Time {
3042      type Raw = raw::git_time;
3043      unsafe fn from_raw(raw: raw::git_time) -> Time {
3044 -        Time { raw: raw }
3045 +        Time { raw }
3046      }
3047      fn raw(&self) -> raw::git_time {
3048          self.raw
3049 @@ -73,8 +73,8 @@
3050      pub fn new(seconds: i32, nanoseconds: u32) -> IndexTime {
3051          unsafe {
3052              Binding::from_raw(raw::git_index_time {
3053 -                seconds: seconds,
3054 -                nanoseconds: nanoseconds,
3055 +                seconds,
3056 +                nanoseconds,
3057              })
3058          }
3059      }
3060 @@ -92,7 +92,7 @@
3061  impl Binding for IndexTime {
3062      type Raw = raw::git_index_time;
3063      unsafe fn from_raw(raw: raw::git_index_time) -> IndexTime {
3064 -        IndexTime { raw: raw }
3065 +        IndexTime { raw }
3066      }
3067      fn raw(&self) -> raw::git_index_time {
3068          self.raw
3069 diff -urN rustc-1.56.0-src/vendor/git2/src/tracing.rs rustc-1.56.0-src-git2/vendor/git2/src/tracing.rs
3070 --- rustc-1.56.0-src/vendor/git2/src/tracing.rs 1970-01-01 01:00:00.000000000 +0100
3071 +++ rustc-1.56.0-src-git2/vendor/git2/src/tracing.rs    2021-10-23 20:47:39.259122276 +0200
3072 @@ -0,0 +1,82 @@
3073 +use std::sync::atomic::{AtomicUsize, Ordering};
3074 +
3075 +use libc::c_char;
3076 +
3077 +use crate::{panic, raw, util::Binding};
3078 +
3079 +/// Available tracing levels.  When tracing is set to a particular level,
3080 +/// callers will be provided tracing at the given level and all lower levels.
3081 +#[derive(Copy, Clone, Debug)]
3082 +pub enum TraceLevel {
3083 +    /// No tracing will be performed.
3084 +    None,
3085 +
3086 +    /// Severe errors that may impact the program's execution
3087 +    Fatal,
3088 +
3089 +    /// Errors that do not impact the program's execution
3090 +    Error,
3091 +
3092 +    /// Warnings that suggest abnormal data
3093 +    Warn,
3094 +
3095 +    /// Informational messages about program execution
3096 +    Info,
3097 +
3098 +    /// Detailed data that allows for debugging
3099 +    Debug,
3100 +
3101 +    /// Exceptionally detailed debugging data
3102 +    Trace,
3103 +}
3104 +
3105 +impl Binding for TraceLevel {
3106 +    type Raw = raw::git_trace_level_t;
3107 +    unsafe fn from_raw(raw: raw::git_trace_level_t) -> Self {
3108 +        match raw {
3109 +            raw::GIT_TRACE_NONE => Self::None,
3110 +            raw::GIT_TRACE_FATAL => Self::Fatal,
3111 +            raw::GIT_TRACE_ERROR => Self::Error,
3112 +            raw::GIT_TRACE_WARN => Self::Warn,
3113 +            raw::GIT_TRACE_INFO => Self::Info,
3114 +            raw::GIT_TRACE_DEBUG => Self::Debug,
3115 +            raw::GIT_TRACE_TRACE => Self::Trace,
3116 +            _ => panic!("Unknown git trace level"),
3117 +        }
3118 +    }
3119 +    fn raw(&self) -> raw::git_trace_level_t {
3120 +        match *self {
3121 +            Self::None => raw::GIT_TRACE_NONE,
3122 +            Self::Fatal => raw::GIT_TRACE_FATAL,
3123 +            Self::Error => raw::GIT_TRACE_ERROR,
3124 +            Self::Warn => raw::GIT_TRACE_WARN,
3125 +            Self::Info => raw::GIT_TRACE_INFO,
3126 +            Self::Debug => raw::GIT_TRACE_DEBUG,
3127 +            Self::Trace => raw::GIT_TRACE_TRACE,
3128 +        }
3129 +    }
3130 +}
3131 +
3132 +pub type TracingCb = fn(TraceLevel, &str);
3133 +
3134 +static CALLBACK: AtomicUsize = AtomicUsize::new(0);
3135 +
3136 +///
3137 +pub fn trace_set(level: TraceLevel, cb: TracingCb) -> bool {
3138 +    CALLBACK.store(cb as usize, Ordering::SeqCst);
3139 +
3140 +    unsafe {
3141 +        raw::git_trace_set(level.raw(), Some(tracing_cb_c));
3142 +    }
3143 +
3144 +    return true;
3145 +}
3146 +
3147 +extern "C" fn tracing_cb_c(level: raw::git_trace_level_t, msg: *const c_char) {
3148 +    let cb = CALLBACK.load(Ordering::SeqCst);
3149 +    panic::wrap(|| unsafe {
3150 +        let cb: TracingCb = std::mem::transmute(cb);
3151 +        let msg = std::ffi::CStr::from_ptr(msg).to_str().unwrap();
3152 +        cb(Binding::from_raw(level), msg);
3153 +    });
3154 +}
3155 diff -urN rustc-1.56.0-src/vendor/git2/src/transaction.rs rustc-1.56.0-src-git2/vendor/git2/src/transaction.rs
3156 --- rustc-1.56.0-src/vendor/git2/src/transaction.rs     1970-01-01 01:00:00.000000000 +0100
3157 +++ rustc-1.56.0-src-git2/vendor/git2/src/transaction.rs        2021-10-23 20:47:39.259122276 +0200
3158 @@ -0,0 +1,285 @@
3159 +use std::ffi::CString;
3160 +use std::marker;
3161 +
3162 +use crate::{raw, util::Binding, Error, Oid, Reflog, Repository, Signature};
3163 +
3164 +/// A structure representing a transactional update of a repository's references.
3165 +///
3166 +/// Transactions work by locking loose refs for as long as the [`Transaction`]
3167 +/// is held, and committing all changes to disk when [`Transaction::commit`] is
3168 +/// called. Note that comitting is not atomic: if an operation fails, the
3169 +/// transaction aborts, but previous successful operations are not rolled back.
3170 +pub struct Transaction<'repo> {
3171 +    raw: *mut raw::git_transaction,
3172 +    _marker: marker::PhantomData<&'repo Repository>,
3173 +}
3174 +
3175 +impl Drop for Transaction<'_> {
3176 +    fn drop(&mut self) {
3177 +        unsafe { raw::git_transaction_free(self.raw) }
3178 +    }
3179 +}
3180 +
3181 +impl<'repo> Binding for Transaction<'repo> {
3182 +    type Raw = *mut raw::git_transaction;
3183 +
3184 +    unsafe fn from_raw(ptr: *mut raw::git_transaction) -> Transaction<'repo> {
3185 +        Transaction {
3186 +            raw: ptr,
3187 +            _marker: marker::PhantomData,
3188 +        }
3189 +    }
3190 +
3191 +    fn raw(&self) -> *mut raw::git_transaction {
3192 +        self.raw
3193 +    }
3194 +}
3195 +
3196 +impl<'repo> Transaction<'repo> {
3197 +    /// Lock the specified reference by name.
3198 +    pub fn lock_ref(&mut self, refname: &str) -> Result<(), Error> {
3199 +        let refname = CString::new(refname).unwrap();
3200 +        unsafe {
3201 +            try_call!(raw::git_transaction_lock_ref(self.raw, refname));
3202 +        }
3203 +
3204 +        Ok(())
3205 +    }
3206 +
3207 +    /// Set the target of the specified reference.
3208 +    ///
3209 +    /// The reference must have been locked via `lock_ref`.
3210 +    ///
3211 +    /// If `reflog_signature` is `None`, the [`Signature`] is read from the
3212 +    /// repository config.
3213 +    pub fn set_target(
3214 +        &mut self,
3215 +        refname: &str,
3216 +        target: Oid,
3217 +        reflog_signature: Option<&Signature<'_>>,
3218 +        reflog_message: &str,
3219 +    ) -> Result<(), Error> {
3220 +        let refname = CString::new(refname).unwrap();
3221 +        let reflog_message = CString::new(reflog_message).unwrap();
3222 +        unsafe {
3223 +            try_call!(raw::git_transaction_set_target(
3224 +                self.raw,
3225 +                refname,
3226 +                target.raw(),
3227 +                reflog_signature.map(|s| s.raw()),
3228 +                reflog_message
3229 +            ));
3230 +        }
3231 +
3232 +        Ok(())
3233 +    }
3234 +
3235 +    /// Set the target of the specified symbolic reference.
3236 +    ///
3237 +    /// The reference must have been locked via `lock_ref`.
3238 +    ///
3239 +    /// If `reflog_signature` is `None`, the [`Signature`] is read from the
3240 +    /// repository config.
3241 +    pub fn set_symbolic_target(
3242 +        &mut self,
3243 +        refname: &str,
3244 +        target: &str,
3245 +        reflog_signature: Option<&Signature<'_>>,
3246 +        reflog_message: &str,
3247 +    ) -> Result<(), Error> {
3248 +        let refname = CString::new(refname).unwrap();
3249 +        let target = CString::new(target).unwrap();
3250 +        let reflog_message = CString::new(reflog_message).unwrap();
3251 +        unsafe {
3252 +            try_call!(raw::git_transaction_set_symbolic_target(
3253 +                self.raw,
3254 +                refname,
3255 +                target,
3256 +                reflog_signature.map(|s| s.raw()),
3257 +                reflog_message
3258 +            ));
3259 +        }
3260 +
3261 +        Ok(())
3262 +    }
3263 +
3264 +    /// Add a [`Reflog`] to the transaction.
3265 +    ///
3266 +    /// This commit the in-memory [`Reflog`] to disk when the transaction commits.
3267 +    /// Note that atomicty is **not* guaranteed: if the transaction fails to
3268 +    /// modify `refname`, the reflog may still have been comitted to disk.
3269 +    ///
3270 +    /// If this is combined with setting the target, that update won't be
3271 +    /// written to the log (ie. the `reflog_signature` and `reflog_message`
3272 +    /// parameters will be ignored).
3273 +    pub fn set_reflog(&mut self, refname: &str, reflog: Reflog) -> Result<(), Error> {
3274 +        let refname = CString::new(refname).unwrap();
3275 +        unsafe {
3276 +            try_call!(raw::git_transaction_set_reflog(
3277 +                self.raw,
3278 +                refname,
3279 +                reflog.raw()
3280 +            ));
3281 +        }
3282 +
3283 +        Ok(())
3284 +    }
3285 +
3286 +    /// Remove a reference.
3287 +    ///
3288 +    /// The reference must have been locked via `lock_ref`.
3289 +    pub fn remove(&mut self, refname: &str) -> Result<(), Error> {
3290 +        let refname = CString::new(refname).unwrap();
3291 +        unsafe {
3292 +            try_call!(raw::git_transaction_remove(self.raw, refname));
3293 +        }
3294 +
3295 +        Ok(())
3296 +    }
3297 +
3298 +    /// Commit the changes from the transaction.
3299 +    ///
3300 +    /// The updates will be made one by one, and the first failure will stop the
3301 +    /// processing.
3302 +    pub fn commit(self) -> Result<(), Error> {
3303 +        unsafe {
3304 +            try_call!(raw::git_transaction_commit(self.raw));
3305 +        }
3306 +        Ok(())
3307 +    }
3308 +}
3309 +
3310 +#[cfg(test)]
3311 +mod tests {
3312 +    use crate::{Error, ErrorClass, ErrorCode, Oid, Repository};
3313 +
3314 +    #[test]
3315 +    fn smoke() {
3316 +        let (_td, repo) = crate::test::repo_init();
3317 +
3318 +        let mut tx = t!(repo.transaction());
3319 +
3320 +        t!(tx.lock_ref("refs/heads/main"));
3321 +        t!(tx.lock_ref("refs/heads/next"));
3322 +
3323 +        t!(tx.set_target("refs/heads/main", Oid::zero(), None, "set main to zero"));
3324 +        t!(tx.set_symbolic_target(
3325 +            "refs/heads/next",
3326 +            "refs/heads/main",
3327 +            None,
3328 +            "set next to main",
3329 +        ));
3330 +
3331 +        t!(tx.commit());
3332 +
3333 +        assert_eq!(repo.refname_to_id("refs/heads/main").unwrap(), Oid::zero());
3334 +        assert_eq!(
3335 +            repo.find_reference("refs/heads/next")
3336 +                .unwrap()
3337 +                .symbolic_target()
3338 +                .unwrap(),
3339 +            "refs/heads/main"
3340 +        );
3341 +    }
3342 +
3343 +    #[test]
3344 +    fn locks_same_repo_handle() {
3345 +        let (_td, repo) = crate::test::repo_init();
3346 +
3347 +        let mut tx1 = t!(repo.transaction());
3348 +        t!(tx1.lock_ref("refs/heads/seen"));
3349 +
3350 +        let mut tx2 = t!(repo.transaction());
3351 +        assert!(matches!(tx2.lock_ref("refs/heads/seen"), Err(e) if e.code() == ErrorCode::Locked))
3352 +    }
3353 +
3354 +    #[test]
3355 +    fn locks_across_repo_handles() {
3356 +        let (td, repo1) = crate::test::repo_init();
3357 +        let repo2 = t!(Repository::open(&td));
3358 +
3359 +        let mut tx1 = t!(repo1.transaction());
3360 +        t!(tx1.lock_ref("refs/heads/seen"));
3361 +
3362 +        let mut tx2 = t!(repo2.transaction());
3363 +        assert!(matches!(tx2.lock_ref("refs/heads/seen"), Err(e) if e.code() == ErrorCode::Locked))
3364 +    }
3365 +
3366 +    #[test]
3367 +    fn drop_unlocks() {
3368 +        let (_td, repo) = crate::test::repo_init();
3369 +
3370 +        let mut tx = t!(repo.transaction());
3371 +        t!(tx.lock_ref("refs/heads/seen"));
3372 +        drop(tx);
3373 +
3374 +        let mut tx2 = t!(repo.transaction());
3375 +        t!(tx2.lock_ref("refs/heads/seen"))
3376 +    }
3377 +
3378 +    #[test]
3379 +    fn commit_unlocks() {
3380 +        let (_td, repo) = crate::test::repo_init();
3381 +
3382 +        let mut tx = t!(repo.transaction());
3383 +        t!(tx.lock_ref("refs/heads/seen"));
3384 +        t!(tx.commit());
3385 +
3386 +        let mut tx2 = t!(repo.transaction());
3387 +        t!(tx2.lock_ref("refs/heads/seen"));
3388 +    }
3389 +
3390 +    #[test]
3391 +    fn prevents_non_transactional_updates() {
3392 +        let (_td, repo) = crate::test::repo_init();
3393 +        let head = t!(repo.refname_to_id("HEAD"));
3394 +
3395 +        let mut tx = t!(repo.transaction());
3396 +        t!(tx.lock_ref("refs/heads/seen"));
3397 +
3398 +        assert!(matches!(
3399 +            repo.reference("refs/heads/seen", head, true, "competing with lock"),
3400 +            Err(e) if e.code() == ErrorCode::Locked
3401 +        ));
3402 +    }
3403 +
3404 +    #[test]
3405 +    fn remove() {
3406 +        let (_td, repo) = crate::test::repo_init();
3407 +        let head = t!(repo.refname_to_id("HEAD"));
3408 +        let next = "refs/heads/next";
3409 +
3410 +        t!(repo.reference(
3411 +            next,
3412 +            head,
3413 +            true,
3414 +            "refs/heads/next@{0}: branch: Created from HEAD"
3415 +        ));
3416 +
3417 +        {
3418 +            let mut tx = t!(repo.transaction());
3419 +            t!(tx.lock_ref(next));
3420 +            t!(tx.remove(next));
3421 +            t!(tx.commit());
3422 +        }
3423 +        assert!(matches!(repo.refname_to_id(next), Err(e) if e.code() == ErrorCode::NotFound))
3424 +    }
3425 +
3426 +    #[test]
3427 +    fn must_lock_ref() {
3428 +        let (_td, repo) = crate::test::repo_init();
3429 +
3430 +        // 🤷
3431 +        fn is_not_locked_err(e: &Error) -> bool {
3432 +            e.code() == ErrorCode::NotFound
3433 +                && e.class() == ErrorClass::Reference
3434 +                && e.message() == "the specified reference is not locked"
3435 +        }
3436 +
3437 +        let mut tx = t!(repo.transaction());
3438 +        assert!(matches!(
3439 +            tx.set_target("refs/heads/main", Oid::zero(), None, "set main to zero"),
3440 +            Err(e) if is_not_locked_err(&e)
3441 +        ))
3442 +    }
3443 +}
3444 diff -urN rustc-1.56.0-src/vendor/git2/src/transport.rs rustc-1.56.0-src-git2/vendor/git2/src/transport.rs
3445 --- rustc-1.56.0-src/vendor/git2/src/transport.rs       2021-10-18 13:05:54.000000000 +0200
3446 +++ rustc-1.56.0-src-git2/vendor/git2/src/transport.rs  2021-10-23 20:47:39.259122276 +0200
3447 @@ -54,7 +54,7 @@
3448  }
3449
3450  /// Actions that a smart transport can ask a subtransport to perform
3451 -#[derive(Copy, Clone)]
3452 +#[derive(Copy, Clone, PartialEq)]
3453  #[allow(missing_docs)]
3454  pub enum Service {
3455      UploadPackLs,
3456 @@ -87,6 +87,8 @@
3457  #[repr(C)]
3458  struct RawSmartSubtransport {
3459      raw: raw::git_smart_subtransport,
3460 +    stream: Option<*mut raw::git_smart_subtransport_stream>,
3461 +    rpc: bool,
3462      obj: Box<dyn SmartSubtransport>,
3463  }
3464
3465 @@ -142,6 +144,8 @@
3466                  close: Some(subtransport_close),
3467                  free: Some(subtransport_free),
3468              },
3469 +            stream: None,
3470 +            rpc,
3471              obj: Box::new(subtransport),
3472          });
3473          let mut defn = raw::git_smart_subtransport_definition {
3474 @@ -246,23 +250,36 @@
3475              raw::GIT_SERVICE_RECEIVEPACK => Service::ReceivePack,
3476              n => panic!("unknown action: {}", n),
3477          };
3478 -        let transport = &mut *(raw_transport as *mut RawSmartSubtransport);
3479 -        let obj = match transport.obj.action(url, action) {
3480 -            Ok(s) => s,
3481 -            Err(e) => {
3482 -                set_err(&e);
3483 -                return e.raw_code() as c_int;
3484 +
3485 +        let mut transport = &mut *(raw_transport as *mut RawSmartSubtransport);
3486 +        // Note: we only need to generate if rpc is on. Else, for receive-pack and upload-pack
3487 +        // libgit2 reuses the stream generated for receive-pack-ls or upload-pack-ls.
3488 +        let generate_stream =
3489 +            transport.rpc || action == Service::UploadPackLs || action == Service::ReceivePackLs;
3490 +        if generate_stream {
3491 +            let obj = match transport.obj.action(url, action) {
3492 +                Ok(s) => s,
3493 +                Err(e) => {
3494 +                    set_err(&e);
3495 +                    return e.raw_code() as c_int;
3496 +                }
3497 +            };
3498 +            *stream = mem::transmute(Box::new(RawSmartSubtransportStream {
3499 +                raw: raw::git_smart_subtransport_stream {
3500 +                    subtransport: raw_transport,
3501 +                    read: Some(stream_read),
3502 +                    write: Some(stream_write),
3503 +                    free: Some(stream_free),
3504 +                },
3505 +                obj,
3506 +            }));
3507 +            transport.stream = Some(*stream);
3508 +        } else {
3509 +            if transport.stream.is_none() {
3510 +                return -1;
3511              }
3512 -        };
3513 -        *stream = mem::transmute(Box::new(RawSmartSubtransportStream {
3514 -            raw: raw::git_smart_subtransport_stream {
3515 -                subtransport: raw_transport,
3516 -                read: Some(stream_read),
3517 -                write: Some(stream_write),
3518 -                free: Some(stream_free),
3519 -            },
3520 -            obj: obj,
3521 -        }));
3522 +            *stream = transport.stream.unwrap();
3523 +        }
3524          0
3525      })
3526      .unwrap_or(-1)
3527 diff -urN rustc-1.56.0-src/vendor/git2/src/treebuilder.rs rustc-1.56.0-src-git2/vendor/git2/src/treebuilder.rs
3528 --- rustc-1.56.0-src/vendor/git2/src/treebuilder.rs     2021-10-18 13:05:54.000000000 +0200
3529 +++ rustc-1.56.0-src-git2/vendor/git2/src/treebuilder.rs        2021-10-23 20:47:39.259122276 +0200
3530 @@ -141,7 +141,7 @@
3531
3532      unsafe fn from_raw(raw: *mut raw::git_treebuilder) -> TreeBuilder<'repo> {
3533          TreeBuilder {
3534 -            raw: raw,
3535 +            raw,
3536              _marker: marker::PhantomData,
3537          }
3538      }
3539 diff -urN rustc-1.56.0-src/vendor/git2/src/tree.rs rustc-1.56.0-src-git2/vendor/git2/src/tree.rs
3540 --- rustc-1.56.0-src/vendor/git2/src/tree.rs    2021-10-18 13:05:54.000000000 +0200
3541 +++ rustc-1.56.0-src-git2/vendor/git2/src/tree.rs       2021-10-23 20:47:39.259122276 +0200
3542 @@ -225,7 +225,7 @@
3543
3544      unsafe fn from_raw(raw: *mut raw::git_tree) -> Tree<'repo> {
3545          Tree {
3546 -            raw: raw,
3547 +            raw,
3548              _marker: marker::PhantomData,
3549          }
3550      }
3551 @@ -334,7 +334,7 @@
3552      type Raw = *mut raw::git_tree_entry;
3553      unsafe fn from_raw(raw: *mut raw::git_tree_entry) -> TreeEntry<'a> {
3554          TreeEntry {
3555 -            raw: raw,
3556 +            raw,
3557              owned: true,
3558              _marker: marker::PhantomData,
3559          }
3560 diff -urN rustc-1.56.0-src/vendor/git2/src/version.rs rustc-1.56.0-src-git2/vendor/git2/src/version.rs
3561 --- rustc-1.56.0-src/vendor/git2/src/version.rs 1970-01-01 01:00:00.000000000 +0100
3562 +++ rustc-1.56.0-src-git2/vendor/git2/src/version.rs    2021-10-23 20:47:39.259122276 +0200
3563 @@ -0,0 +1,95 @@
3564 +use crate::raw;
3565 +use libc::c_int;
3566 +use std::fmt;
3567 +
3568 +/// Version information about libgit2 and the capabilities it supports.
3569 +pub struct Version {
3570 +    major: c_int,
3571 +    minor: c_int,
3572 +    rev: c_int,
3573 +    features: c_int,
3574 +}
3575 +
3576 +macro_rules! flag_test {
3577 +    ($features:expr, $flag:expr) => {
3578 +        ($features as u32 & $flag as u32) != 0
3579 +    };
3580 +}
3581 +
3582 +impl Version {
3583 +    /// Returns a [`Version`] which provides information about libgit2.
3584 +    pub fn get() -> Version {
3585 +        let mut v = Version {
3586 +            major: 0,
3587 +            minor: 0,
3588 +            rev: 0,
3589 +            features: 0,
3590 +        };
3591 +        unsafe {
3592 +            raw::git_libgit2_version(&mut v.major, &mut v.minor, &mut v.rev);
3593 +            v.features = raw::git_libgit2_features();
3594 +        }
3595 +        v
3596 +    }
3597 +
3598 +    /// Returns the version of libgit2.
3599 +    ///
3600 +    /// The return value is a tuple of `(major, minor, rev)`
3601 +    pub fn libgit2_version(&self) -> (u32, u32, u32) {
3602 +        (self.major as u32, self.minor as u32, self.rev as u32)
3603 +    }
3604 +
3605 +    /// Returns the version of the libgit2-sys crate.
3606 +    pub fn crate_version(&self) -> &'static str {
3607 +        env!("CARGO_PKG_VERSION")
3608 +    }
3609 +
3610 +    /// Returns true if this was built with the vendored version of libgit2.
3611 +    pub fn vendored(&self) -> bool {
3612 +        raw::vendored()
3613 +    }
3614 +
3615 +    /// Returns true if libgit2 was built thread-aware and can be safely used
3616 +    /// from multiple threads.
3617 +    pub fn threads(&self) -> bool {
3618 +        flag_test!(self.features, raw::GIT_FEATURE_THREADS)
3619 +    }
3620 +
3621 +    /// Returns true if libgit2 was built with and linked against a TLS implementation.
3622 +    ///
3623 +    /// Custom TLS streams may still be added by the user to support HTTPS
3624 +    /// regardless of this.
3625 +    pub fn https(&self) -> bool {
3626 +        flag_test!(self.features, raw::GIT_FEATURE_HTTPS)
3627 +    }
3628 +
3629 +    /// Returns true if libgit2 was built with and linked against libssh2.
3630 +    ///
3631 +    /// A custom transport may still be added by the user to support libssh2
3632 +    /// regardless of this.
3633 +    pub fn ssh(&self) -> bool {
3634 +        flag_test!(self.features, raw::GIT_FEATURE_SSH)
3635 +    }
3636 +
3637 +    /// Returns true if libgit2 was built with support for sub-second
3638 +    /// resolution in file modification times.
3639 +    pub fn nsec(&self) -> bool {
3640 +        flag_test!(self.features, raw::GIT_FEATURE_NSEC)
3641 +    }
3642 +}
3643 +
3644 +impl fmt::Debug for Version {
3645 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
3646 +        let mut f = f.debug_struct("Version");
3647 +        f.field("major", &self.major)
3648 +            .field("minor", &self.minor)
3649 +            .field("rev", &self.rev)
3650 +            .field("crate_version", &self.crate_version())
3651 +            .field("vendored", &self.vendored())
3652 +            .field("threads", &self.threads())
3653 +            .field("https", &self.https())
3654 +            .field("ssh", &self.ssh())
3655 +            .field("nsec", &self.nsec());
3656 +        f.finish()
3657 +    }
3658 +}
3659 diff -urN rustc-1.56.0-src/vendor/libgit2-sys/build.rs rustc-1.56.0-src-git2/vendor/libgit2-sys/build.rs
3660 --- rustc-1.56.0-src/vendor/libgit2-sys/build.rs        2021-10-18 13:05:54.000000000 +0200
3661 +++ rustc-1.56.0-src-git2/vendor/libgit2-sys/build.rs   2021-10-23 20:47:39.259122276 +0200
3662 @@ -7,10 +7,12 @@
3663  fn main() {
3664      let https = env::var("CARGO_FEATURE_HTTPS").is_ok();
3665      let ssh = env::var("CARGO_FEATURE_SSH").is_ok();
3666 +    let vendored = env::var("CARGO_FEATURE_VENDORED").is_ok();
3667      let zlib_ng_compat = env::var("CARGO_FEATURE_ZLIB_NG_COMPAT").is_ok();
3668
3669      // To use zlib-ng in zlib-compat mode, we have to build libgit2 ourselves.
3670 -    if !zlib_ng_compat {
3671 +    let try_to_use_system_libgit2 = !vendored && !zlib_ng_compat;
3672 +    if try_to_use_system_libgit2 {
3673          let mut cfg = pkg_config::Config::new();
3674          if let Ok(lib) = cfg.atleast_version("1.1.0").probe("libgit2") {
3675              for include in &lib.include_paths {
3676 @@ -20,6 +22,8 @@
3677          }
3678      }
3679
3680 +    println!("cargo:rustc-cfg=libgit2_vendored");
3681 +
3682      if !Path::new("libgit2/.git").exists() {
3683          let _ = Command::new("git")
3684              .args(&["submodule", "update", "--init", "libgit2"])
3685 @@ -107,6 +111,7 @@
3686      features.push_str("#ifndef INCLUDE_features_h\n");
3687      features.push_str("#define INCLUDE_features_h\n");
3688      features.push_str("#define GIT_THREADS 1\n");
3689 +    features.push_str("#define GIT_TRACE 1\n");
3690
3691      if !target.contains("android") {
3692          features.push_str("#define GIT_USE_NSEC 1\n");
3693 diff -urN rustc-1.56.0-src/vendor/libgit2-sys/Cargo.toml rustc-1.56.0-src-git2/vendor/libgit2-sys/Cargo.toml
3694 --- rustc-1.56.0-src/vendor/libgit2-sys/Cargo.toml      2021-10-18 13:05:54.000000000 +0200
3695 +++ rustc-1.56.0-src-git2/vendor/libgit2-sys/Cargo.toml 2021-10-23 20:47:39.259122276 +0200
3696 @@ -13,7 +13,7 @@
3697  [package]
3698  edition = "2018"
3699  name = "libgit2-sys"
3700 -version = "0.12.18+1.1.0"
3701 +version = "0.12.24+1.3.0"
3702  authors = ["Josh Triplett <josh@joshtriplett.org>", "Alex Crichton <alex@alexcrichton.com>"]
3703  build = "build.rs"
3704  links = "git2"
3705 diff -urN rustc-1.56.0-src/vendor/libgit2-sys/lib.rs rustc-1.56.0-src-git2/vendor/libgit2-sys/lib.rs
3706 --- rustc-1.56.0-src/vendor/libgit2-sys/lib.rs  2021-10-18 13:05:54.000000000 +0200
3707 +++ rustc-1.56.0-src-git2/vendor/libgit2-sys/lib.rs     2021-10-23 20:47:39.259122276 +0200
3708 @@ -89,6 +89,8 @@
3709  pub enum git_odb_stream {}
3710  pub enum git_odb_object {}
3711  pub enum git_worktree {}
3712 +pub enum git_transaction {}
3713 +pub enum git_mailmap {}
3714
3715  #[repr(C)]
3716  pub struct git_revspec {
3717 @@ -351,6 +353,8 @@
3718  )]
3719  pub type git_transfer_progress = git_indexer_progress;
3720
3721 +pub type git_remote_ready_cb = Option<extern "C" fn(*mut git_remote, c_int, *mut c_void) -> c_int>;
3722 +
3723  #[repr(C)]
3724  pub struct git_remote_callbacks {
3725      pub version: c_uint,
3726 @@ -366,6 +370,7 @@
3727      pub push_update_reference: git_push_update_reference_cb,
3728      pub push_negotiation: git_push_negotiation,
3729      pub transport: git_transport_cb,
3730 +    pub remote_ready: git_remote_ready_cb,
3731      pub payload: *mut c_void,
3732      pub resolve_url: git_url_resolve_cb,
3733  }
3734 @@ -1167,6 +1172,7 @@
3735  pub const GIT_DIFF_INCLUDE_UNREADABLE: git_diff_option_t = 1 << 16;
3736  pub const GIT_DIFF_INCLUDE_UNREADABLE_AS_UNTRACKED: git_diff_option_t = 1 << 17;
3737  pub const GIT_DIFF_INDENT_HEURISTIC: git_diff_option_t = 1 << 18;
3738 +pub const GIT_DIFF_IGNORE_BLANK_LINES: git_diff_option_t = 1 << 19;
3739  pub const GIT_DIFF_FORCE_TEXT: git_diff_option_t = 1 << 20;
3740  pub const GIT_DIFF_FORCE_BINARY: git_diff_option_t = 1 << 21;
3741  pub const GIT_DIFF_IGNORE_WHITESPACE: git_diff_option_t = 1 << 22;
3742 @@ -1247,6 +1253,13 @@
3743  pub const GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER: u32 = 1 << 0;
3744
3745  #[repr(C)]
3746 +pub struct git_diff_patchid_options {
3747 +    pub version: c_uint,
3748 +}
3749 +
3750 +pub const GIT_DIFF_PATCHID_OPTIONS_VERSION: c_uint = 1;
3751 +
3752 +#[repr(C)]
3753  pub struct git_diff_binary {
3754      pub contains_data: c_uint,
3755      pub old_file: git_diff_binary_file,
3756 @@ -1477,6 +1490,8 @@
3757          ) -> c_int,
3758      >,
3759
3760 +    pub writemidx: Option<extern "C" fn(*mut git_odb_backend) -> c_int>,
3761 +
3762      pub freshen: Option<extern "C" fn(*mut git_odb_backend, *const git_oid) -> c_int>,
3763
3764      pub free: Option<extern "C" fn(*mut git_odb_backend)>,
3765 @@ -1736,6 +1751,20 @@
3766      ) -> c_int,
3767  >;
3768
3769 +pub type git_commit_create_cb = Option<
3770 +    extern "C" fn(
3771 +        *mut git_oid,
3772 +        *const git_signature,
3773 +        *const git_signature,
3774 +        *const c_char,
3775 +        *const c_char,
3776 +        *const git_tree,
3777 +        usize,
3778 +        *const git_commit,
3779 +        *mut c_void,
3780 +    ) -> c_int,
3781 +>;
3782 +
3783  pub const GIT_REBASE_NO_OPERATION: usize = usize::max_value();
3784
3785  #[repr(C)]
3786 @@ -1746,6 +1775,7 @@
3787      pub rewrite_notes_ref: *const c_char,
3788      pub merge_options: git_merge_options,
3789      pub checkout_options: git_checkout_options,
3790 +    pub commit_create_cb: git_commit_create_cb,
3791      pub signing_cb: git_commit_signing_cb,
3792      pub payload: *mut c_void,
3793  }
3794 @@ -1880,6 +1910,63 @@
3795
3796  pub const GIT_WORKTREE_PRUNE_OPTIONS_VERSION: c_uint = 1;
3797
3798 +pub type git_repository_mergehead_foreach_cb =
3799 +    Option<extern "C" fn(oid: *const git_oid, payload: *mut c_void) -> c_int>;
3800 +
3801 +pub type git_repository_fetchhead_foreach_cb = Option<
3802 +    extern "C" fn(*const c_char, *const c_char, *const git_oid, c_uint, *mut c_void) -> c_int,
3803 +>;
3804 +
3805 +git_enum! {
3806 +    pub enum git_trace_level_t {
3807 +        /* No tracing will be performed. */
3808 +        GIT_TRACE_NONE = 0,
3809 +
3810 +        /* Severe errors that may impact the program's execution */
3811 +        GIT_TRACE_FATAL = 1,
3812 +
3813 +        /* Errors that do not impact the program's execution */
3814 +        GIT_TRACE_ERROR = 2,
3815 +
3816 +        /* Warnings that suggest abnormal data */
3817 +        GIT_TRACE_WARN = 3,
3818 +
3819 +        /* Informational messages about program execution */
3820 +        GIT_TRACE_INFO = 4,
3821 +
3822 +        /* Detailed data that allows for debugging */
3823 +        GIT_TRACE_DEBUG = 5,
3824 +
3825 +        /* Exceptionally detailed debugging data */
3826 +        GIT_TRACE_TRACE = 6,
3827 +    }
3828 +}
3829 +
3830 +pub type git_trace_cb = Option<extern "C" fn(level: git_trace_level_t, msg: *const c_char)>;
3831 +
3832 +git_enum! {
3833 +    pub enum git_feature_t {
3834 +        GIT_FEATURE_THREADS = 1 << 0,
3835 +        GIT_FEATURE_HTTPS   = 1 << 1,
3836 +        GIT_FEATURE_SSH     = 1 << 2,
3837 +        GIT_FEATURE_NSEC    = 1 << 3,
3838 +    }
3839 +}
3840 +
3841 +#[repr(C)]
3842 +pub struct git_message_trailer {
3843 +    pub key: *const c_char,
3844 +    pub value: *const c_char,
3845 +}
3846 +
3847 +#[repr(C)]
3848 +#[derive(Copy, Clone)]
3849 +pub struct git_message_trailer_array {
3850 +    pub trailers: *mut git_message_trailer,
3851 +    pub count: size_t,
3852 +    pub _trailer_block: *mut c_char,
3853 +}
3854 +
3855  extern "C" {
3856      // threads
3857      pub fn git_libgit2_init() -> c_int;
3858 @@ -1972,6 +2059,16 @@
3859          repo: *mut git_repository,
3860          recurse_submodules: c_int,
3861      ) -> c_int;
3862 +    pub fn git_repository_mergehead_foreach(
3863 +        repo: *mut git_repository,
3864 +        callback: git_repository_mergehead_foreach_cb,
3865 +        payload: *mut c_void,
3866 +    ) -> c_int;
3867 +    pub fn git_repository_fetchhead_foreach(
3868 +        repo: *mut git_repository,
3869 +        callback: git_repository_fetchhead_foreach_cb,
3870 +        payload: *mut c_void,
3871 +    ) -> c_int;
3872      pub fn git_ignore_add_rule(repo: *mut git_repository, rules: *const c_char) -> c_int;
3873      pub fn git_ignore_clear_internal_rules(repo: *mut git_repository) -> c_int;
3874      pub fn git_ignore_path_is_ignored(
3875 @@ -2409,6 +2506,7 @@
3876      ) -> c_int;
3877      pub fn git_submodule_free(submodule: *mut git_submodule);
3878      pub fn git_submodule_head_id(submodule: *mut git_submodule) -> *const git_oid;
3879 +    pub fn git_submodule_ignore(submodule: *mut git_submodule) -> git_submodule_ignore_t;
3880      pub fn git_submodule_index_id(submodule: *mut git_submodule) -> *const git_oid;
3881      pub fn git_submodule_init(submodule: *mut git_submodule, overwrite: c_int) -> c_int;
3882      pub fn git_submodule_location(status: *mut c_uint, submodule: *mut git_submodule) -> c_int;
3883 @@ -2589,7 +2687,17 @@
3884
3885      // commit
3886      pub fn git_commit_author(commit: *const git_commit) -> *const git_signature;
3887 +    pub fn git_commit_author_with_mailmap(
3888 +        out: *mut *mut git_signature,
3889 +        commit: *const git_commit,
3890 +        mailmap: *const git_mailmap,
3891 +    ) -> c_int;
3892      pub fn git_commit_committer(commit: *const git_commit) -> *const git_signature;
3893 +    pub fn git_commit_committer_with_mailmap(
3894 +        out: *mut *mut git_signature,
3895 +        commit: *const git_commit,
3896 +        mailmap: *const git_mailmap,
3897 +    ) -> c_int;
3898      pub fn git_commit_free(commit: *mut git_commit);
3899      pub fn git_commit_id(commit: *const git_commit) -> *const git_oid;
3900      pub fn git_commit_lookup(
3901 @@ -2712,6 +2820,7 @@
3902          force: c_int,
3903      ) -> c_int;
3904      pub fn git_branch_name(out: *mut *const c_char, branch: *const git_reference) -> c_int;
3905 +    pub fn git_branch_name_is_valid(valid: *mut c_int, name: *const c_char) -> c_int;
3906      pub fn git_branch_remote_name(
3907          out: *mut git_buf,
3908          repo: *mut git_repository,
3909 @@ -3434,6 +3543,16 @@
3910          version: c_uint,
3911      ) -> c_int;
3912
3913 +    pub fn git_diff_patchid(
3914 +        out: *mut git_oid,
3915 +        diff: *mut git_diff,
3916 +        opts: *mut git_diff_patchid_options,
3917 +    ) -> c_int;
3918 +    pub fn git_diff_patchid_options_init(
3919 +        opts: *mut git_diff_patchid_options,
3920 +        version: c_uint,
3921 +    ) -> c_int;
3922 +
3923      // patch
3924      pub fn git_patch_from_diff(out: *mut *mut git_patch, diff: *mut git_diff, idx: size_t)
3925          -> c_int;
3926 @@ -3573,6 +3692,13 @@
3927          comment_char: c_char,
3928      ) -> c_int;
3929
3930 +    pub fn git_message_trailers(
3931 +        out: *mut git_message_trailer_array,
3932 +        message: *const c_char,
3933 +    ) -> c_int;
3934 +
3935 +    pub fn git_message_trailer_array_free(trailer: *mut git_message_trailer_array);
3936 +
3937      // packbuilder
3938      pub fn git_packbuilder_new(out: *mut *mut git_packbuilder, repo: *mut git_repository) -> c_int;
3939      pub fn git_packbuilder_set_threads(pb: *mut git_packbuilder, n: c_uint) -> c_uint;
3940 @@ -3853,6 +3979,9 @@
3941          given_opts: *const git_revert_options,
3942      ) -> c_int;
3943
3944 +    // Common
3945 +    pub fn git_libgit2_version(major: *mut c_int, minor: *mut c_int, rev: *mut c_int) -> c_int;
3946 +    pub fn git_libgit2_features() -> c_int;
3947      pub fn git_libgit2_opts(option: c_int, ...) -> c_int;
3948
3949      // Worktrees
3950 @@ -3896,6 +4025,59 @@
3951          wt: *mut git_worktree,
3952          opts: *mut git_worktree_prune_options,
3953      ) -> c_int;
3954 +
3955 +    // Ref transactions
3956 +    pub fn git_transaction_new(out: *mut *mut git_transaction, repo: *mut git_repository) -> c_int;
3957 +    pub fn git_transaction_lock_ref(tx: *mut git_transaction, refname: *const c_char) -> c_int;
3958 +    pub fn git_transaction_set_target(
3959 +        tx: *mut git_transaction,
3960 +        refname: *const c_char,
3961 +        target: *const git_oid,
3962 +        sig: *const git_signature,
3963 +        msg: *const c_char,
3964 +    ) -> c_int;
3965 +    pub fn git_transaction_set_symbolic_target(
3966 +        tx: *mut git_transaction,
3967 +        refname: *const c_char,
3968 +        target: *const c_char,
3969 +        sig: *const git_signature,
3970 +        msg: *const c_char,
3971 +    ) -> c_int;
3972 +    pub fn git_transaction_set_reflog(
3973 +        tx: *mut git_transaction,
3974 +        refname: *const c_char,
3975 +        reflog: *const git_reflog,
3976 +    ) -> c_int;
3977 +    pub fn git_transaction_remove(tx: *mut git_transaction, refname: *const c_char) -> c_int;
3978 +    pub fn git_transaction_commit(tx: *mut git_transaction) -> c_int;
3979 +    pub fn git_transaction_free(tx: *mut git_transaction);
3980 +
3981 +    // Mailmap
3982 +    pub fn git_mailmap_new(out: *mut *mut git_mailmap) -> c_int;
3983 +    pub fn git_mailmap_from_buffer(
3984 +        out: *mut *mut git_mailmap,
3985 +        buf: *const c_char,
3986 +        len: size_t,
3987 +    ) -> c_int;
3988 +    pub fn git_mailmap_from_repository(
3989 +        out: *mut *mut git_mailmap,
3990 +        repo: *mut git_repository,
3991 +    ) -> c_int;
3992 +    pub fn git_mailmap_free(mm: *mut git_mailmap);
3993 +    pub fn git_mailmap_resolve_signature(
3994 +        out: *mut *mut git_signature,
3995 +        mm: *const git_mailmap,
3996 +        sig: *const git_signature,
3997 +    ) -> c_int;
3998 +    pub fn git_mailmap_add_entry(
3999 +        mm: *mut git_mailmap,
4000 +        real_name: *const c_char,
4001 +        real_email: *const c_char,
4002 +        replace_name: *const c_char,
4003 +        replace_email: *const c_char,
4004 +    ) -> c_int;
4005 +
4006 +    pub fn git_trace_set(level: git_trace_level_t, cb: git_trace_cb) -> c_int;
4007  }
4008
4009  pub fn init() {
4010 @@ -3944,3 +4126,8 @@
4011
4012  #[cfg(not(feature = "ssh"))]
4013  fn ssh_init() {}
4014 +
4015 +#[doc(hidden)]
4016 +pub fn vendored() -> bool {
4017 +    cfg!(libgit2_vendored)
4018 +}