[pkgsrc/trunk]: pkgsrc/mail/thunderbird Fix build with Rust 1.39.0, bump PKGR...

[ryoon <ryoon%pkgsrc.org@localhost>]

details:   https://anonhg.NetBSD.org/pkgsrc/rev/451f1e8586e7
branches:  trunk
changeset: 404752:451f1e8586e7
user:      ryoon <ryoon%pkgsrc.org@localhost>
date:      Sun Nov 17 11:50:01 2019 +0000

description:
Fix build with Rust 1.39.0, bump PKGREVISION

diffstat:

 mail/thunderbird/Makefile                  |   10 +-
 mail/thunderbird/distinfo                  |    3 +-
 mail/thunderbird/patches/patch-rust-1.39.0 |  176 +++++++++++++++++++++++++++++
 3 files changed, 187 insertions(+), 2 deletions(-)

diffs (225 lines):

diff -r 4c20033d80e6 -r 451f1e8586e7 mail/thunderbird/Makefile
--- a/mail/thunderbird/Makefile Sun Nov 17 11:26:33 2019 +0000
+++ b/mail/thunderbird/Makefile Sun Nov 17 11:50:01 2019 +0000
@@ -1,8 +1,9 @@
-# $NetBSD: Makefile,v 1.234 2019/11/02 16:25:28 rillig Exp $
+# $NetBSD: Makefile,v 1.235 2019/11/17 11:50:01 ryoon Exp $
 
 DISTNAME=      thunderbird-${TB_VER}.source
 PKGNAME=       thunderbird-${TB_VER}
 TB_VER=                68.2.1
+PKGREVISION=   1
 CATEGORIES=    mail
 MASTER_SITES=  ${MASTER_SITE_MOZILLA:=thunderbird/releases/${TB_VER}/source/}
 EXTRACT_SUFX=  .tar.xz
@@ -46,6 +47,13 @@
        ${CP} ${FILESDIR}/cubeb_sun.c ${WRKSRC}/media/libcubeb/src/cubeb_sun.c
        mv ${WRKSRC}${MOZILLA_DIR}/gfx/ycbcr/yuv_row_arm.s \
                ${WRKSRC}${MOZILLA_DIR}/gfx/ycbcr/yuv_row_arm.S
+       ${CP} ${WRKSRC}/third_party/rust/bindgen/.cargo-checksum.json \
+               ${WRKSRC}/third_party/rust/bindgen/.cargo-checksum.json.orig
+       ${CAT} ${WRKSRC}/third_party/rust/bindgen/.cargo-checksum.json.orig | \
+               ${SED} -e 's/5788372d27bdbaaf0454bc17be31a5480918bc41a8a1c4832e8c61185c07f9cd/8c92a52c0f859c7bec7bfbc36b9d18f904baab0c8c9dc1b3e7af34de1a0b0da4/' | \
+               ${SED} -e 's/8dc10043d872e68e660ef96edca4d9733f95be45cdad4893462fa929b335014f/71f1a37f75b971ea5b0d8457473cc410947dbf706cb6d2c0338916910b78a675/' | \
+               ${SED} -e 's/34f9aa76b6c9c05136bb69dcd6455397faef571a567254d2c541d50a962994db/e5581852eec87918901a129284b4965aefc8a19394187a8095779a084f28fabe/' \
+               > ${WRKSRC}/third_party/rust/bindgen/.cargo-checksum.json
 
 pre-configure:
        cd ${WRKSRC} && mkdir ${OBJDIR}
diff -r 4c20033d80e6 -r 451f1e8586e7 mail/thunderbird/distinfo
--- a/mail/thunderbird/distinfo Sun Nov 17 11:26:33 2019 +0000
+++ b/mail/thunderbird/distinfo Sun Nov 17 11:50:01 2019 +0000
@@ -1,4 +1,4 @@
-$NetBSD: distinfo,v 1.217 2019/11/02 13:02:55 ryoon Exp $
+$NetBSD: distinfo,v 1.218 2019/11/17 11:50:01 ryoon Exp $
 
 SHA1 (thunderbird-68.2.1.source.tar.xz) = db31f430e033e777e095924dcbd4715173ae3a4e
 RMD160 (thunderbird-68.2.1.source.tar.xz) = c20fc72db2f0c06d04d0ca904d7850c711406bdd
@@ -31,6 +31,7 @@
 SHA1 (patch-media_libcubeb_update.sh) = f8d0f674987519a1a1738be158e8cd4296f6def0
 SHA1 (patch-media_libpng_pngpriv.h) = dfd4d345e10f6f74d3a3546732a868481c1d5818
 SHA1 (patch-old-configure.in) = 24c2f64250160c9e4c4cdc3b5ff2e6d33a5d6aad
+SHA1 (patch-rust-1.39.0) = 73f41832022fb42c6d84131b6daf9396a1fea284
 SHA1 (patch-toolkit_components_terminator_nsTerminator.cpp) = cd4d65d6e6358b5b77b6b63441a8550f2d1e97c7
 SHA1 (patch-toolkit_library_moz.build) = 429745ec028ce71d8ba2457679b715ac14b6e2d3
 SHA1 (patch-toolkit_modules_subprocess_subprocess__shared__unix.js) = bc5293f7bf4885443a131958e4099bbf0f2c4a2c
diff -r 4c20033d80e6 -r 451f1e8586e7 mail/thunderbird/patches/patch-rust-1.39.0
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/mail/thunderbird/patches/patch-rust-1.39.0        Sun Nov 17 11:50:01 2019 +0000
@@ -0,0 +1,176 @@
+$NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $
+
+From 9696bc1795c75b1b527e2b70d9baf3ced9e3c154 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio%crisal.io@localhost>
+Date: Mon, 23 Sep 2019 17:54:37 +0200
+Subject: [PATCH] ir: Make Ord and PartialOrd implementations agree.
+
+See https://github.com/rust-lang/rust/issues/64710.
+
+Bogus implementations were introduced in 230545e7c, d3e39dc62, and 379bb1663.
+
+--- third_party/rust/bindgen/src/ir/analysis/has_vtable.rs.orig        2019-10-16 19:30:29.000000000 +0000
++++ third_party/rust/bindgen/src/ir/analysis/has_vtable.rs
+@@ -9,17 +9,17 @@ use std::ops;
+ use {HashMap, Entry};
+ 
+ /// The result of the `HasVtableAnalysis` for an individual item.
+-#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)]
++#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+ pub enum HasVtableResult {
+-    /// The item has a vtable, but the actual vtable pointer is in a base
+-    /// member.
+-    BaseHasVtable,
++    /// The item does not have a vtable pointer.
++    No,
+ 
+     /// The item has a vtable and the actual vtable pointer is within this item.
+     SelfHasVtable,
+ 
+-    /// The item does not have a vtable pointer.
+-    No
++    /// The item has a vtable, but the actual vtable pointer is in a base
++    /// member.
++    BaseHasVtable,
+ }
+ 
+ impl Default for HasVtableResult {
+@@ -28,21 +28,6 @@ impl Default for HasVtableResult {
+     }
+ }
+ 
+-impl cmp::PartialOrd for HasVtableResult {
+-    fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
+-        use self::HasVtableResult::*;
+-
+-        match (*self, *rhs) {
+-            (x, y) if x == y => Some(cmp::Ordering::Equal),
+-            (BaseHasVtable, _) => Some(cmp::Ordering::Greater),
+-            (_, BaseHasVtable) => Some(cmp::Ordering::Less),
+-            (SelfHasVtable, _) => Some(cmp::Ordering::Greater),
+-            (_, SelfHasVtable) => Some(cmp::Ordering::Less),
+-            _ => unreachable!(),
+-        }
+-    }
+-}
+-
+ impl HasVtableResult {
+     /// Take the least upper bound of `self` and `rhs`.
+     pub fn join(self, rhs: Self) -> Self {
+$NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $
+
+--- third_party/rust/bindgen/src/ir/analysis/sizedness.rs.orig 2019-10-16 19:30:29.000000000 +0000
++++ third_party/rust/bindgen/src/ir/analysis/sizedness.rs
+@@ -22,13 +22,14 @@ use {HashMap, Entry};
+ ///
+ /// We initially assume that all types are `ZeroSized` and then update our
+ /// understanding as we learn more about each type.
+-#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)]
++#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+ pub enum SizednessResult {
+-    /// Has some size that is known to be greater than zero. That doesn't mean
+-    /// it has a static size, but it is not zero sized for sure. In other words,
+-    /// it might contain an incomplete array or some other dynamically sized
+-    /// type.
+-    NonZeroSized,
++    /// The type is zero-sized.
++    ///
++    /// This means that if it is a C++ type, and is not being used as a base
++    /// member, then we must add an `_address` byte to enforce the
++    /// unique-address-per-distinct-object-instance rule.
++    ZeroSized,
+ 
+     /// Whether this type is zero-sized or not depends on whether a type
+     /// parameter is zero-sized or not.
+@@ -52,12 +53,11 @@ pub enum SizednessResult {
+     /// https://github.com/rust-lang-nursery/rust-bindgen/issues/586
+     DependsOnTypeParam,
+ 
+-    /// The type is zero-sized.
+-    ///
+-    /// This means that if it is a C++ type, and is not being used as a base
+-    /// member, then we must add an `_address` byte to enforce the
+-    /// unique-address-per-distinct-object-instance rule.
+-    ZeroSized,
++    /// Has some size that is known to be greater than zero. That doesn't mean
++    /// it has a static size, but it is not zero sized for sure. In other words,
++    /// it might contain an incomplete array or some other dynamically sized
++    /// type.
++    NonZeroSized,
+ }
+ 
+ impl Default for SizednessResult {
+@@ -66,21 +66,6 @@ impl Default for SizednessResult {
+     }
+ }
+ 
+-impl cmp::PartialOrd for SizednessResult {
+-    fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
+-        use self::SizednessResult::*;
+-
+-        match (*self, *rhs) {
+-            (x, y) if x == y => Some(cmp::Ordering::Equal),
+-            (NonZeroSized, _) => Some(cmp::Ordering::Greater),
+-            (_, NonZeroSized) => Some(cmp::Ordering::Less),
+-            (DependsOnTypeParam, _) => Some(cmp::Ordering::Greater),
+-            (_, DependsOnTypeParam) => Some(cmp::Ordering::Less),
+-            _ => unreachable!(),
+-        }
+-    }
+-}
+-
+ impl SizednessResult {
+     /// Take the least upper bound of `self` and `rhs`.
+     pub fn join(self, rhs: Self) -> Self {
+$NetBSD: patch-rust-1.39.0,v 1.1 2019/11/17 11:50:01 ryoon Exp $
+
+--- third_party/rust/bindgen/src/ir/derive.rs.orig     2019-10-16 19:30:29.000000000 +0000
++++ third_party/rust/bindgen/src/ir/derive.rs
+@@ -92,10 +92,10 @@ pub trait CanDeriveOrd {
+ ///
+ /// Initially we assume that we can derive trait for all types and then
+ /// update our understanding as we learn more about each type.
+-#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord)]
++#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+ pub enum CanDerive {
+-    /// No, we cannot.
+-    No,
++    /// Yes, we can derive automatically.
++    Yes,
+ 
+     /// The only thing that stops us from automatically deriving is that
+     /// array with more than maximum number of elements is used.
+@@ -103,8 +103,8 @@ pub enum CanDerive {
+     /// This means we probably can "manually" implement such trait.
+     Manually,
+ 
+-    /// Yes, we can derive automatically.
+-    Yes,
++    /// No, we cannot.
++    No,
+ }
+ 
+ impl Default for CanDerive {
+@@ -113,22 +113,6 @@ impl Default for CanDerive {
+     }
+ }
+ 
+-impl cmp::PartialOrd for CanDerive {
+-    fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
+-        use self::CanDerive::*;
+-
+-        let ordering = match (*self, *rhs) {
+-            (x, y) if x == y => cmp::Ordering::Equal,
+-            (No, _) => cmp::Ordering::Greater,
+-            (_, No) => cmp::Ordering::Less,
+-            (Manually, _) => cmp::Ordering::Greater,
+-            (_, Manually) => cmp::Ordering::Less,
+-            _ => unreachable!()
+-        };
+-        Some(ordering)
+-    }
+-}
+-
+ impl CanDerive {
+     /// Take the least upper bound of `self` and `rhs`.
+     pub fn join(self, rhs: Self) -> Self {