Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

25 files changed, 559 insertions, 0 deletions

diff --git a/vendor/bitflags/tests/basic.rs b/vendor/bitflags/tests/basic.rs
new file mode 100644
index 000000000..73a52bec5
--- /dev/null
+++ b/vendor/bitflags/tests/basic.rs
@@ -0,0 +1,20 @@
+#![no_std]
+
+use bitflags::bitflags;
+
+bitflags! {
+    /// baz
+    struct Flags: u32 {
+        const A = 0b00000001;
+        #[doc = "bar"]
+        const B = 0b00000010;
+        const C = 0b00000100;
+        #[doc = "foo"]
+        const ABC = Flags::A.bits | Flags::B.bits | Flags::C.bits;
+    }
+}
+
+#[test]
+fn basic() {
+    assert_eq!(Flags::ABC, Flags::A | Flags::B | Flags::C);
+}
diff --git a/vendor/bitflags/tests/compile-fail/impls/copy.rs b/vendor/bitflags/tests/compile-fail/impls/copy.rs
new file mode 100644
index 000000000..38f4822f5
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/impls/copy.rs
@@ -0,0 +1,10 @@
+use bitflags::bitflags;
+
+bitflags! {
+    #[derive(Clone, Copy)]
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta b/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta
new file mode 100644
index 000000000..0c13aa502
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta
@@ -0,0 +1,27 @@
+error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Flags`
+ --> $DIR/copy.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(Clone, Copy)]
+  | |              ----- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `Flags`
+ --> $DIR/copy.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(Clone, Copy)]
+  | |                     ---- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/impls/eq.rs b/vendor/bitflags/tests/compile-fail/impls/eq.rs
new file mode 100644
index 000000000..4abbd630c
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/impls/eq.rs
@@ -0,0 +1,10 @@
+use bitflags::bitflags;
+
+bitflags! {
+    #[derive(PartialEq, Eq)]
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta b/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta
new file mode 100644
index 000000000..8a1a3b410
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta
@@ -0,0 +1,55 @@
+error[E0119]: conflicting implementations of trait `std::cmp::PartialEq` for type `Flags`
+ --> $DIR/eq.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(PartialEq, Eq)]
+  | |              --------- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::cmp::Eq` for type `Flags`
+ --> $DIR/eq.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(PartialEq, Eq)]
+  | |                         -- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::StructuralPartialEq` for type `Flags`
+ --> $DIR/eq.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(PartialEq, Eq)]
+  | |              --------- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::StructuralEq` for type `Flags`
+ --> $DIR/eq.rs:3:1
+  |
+3 | / bitflags! {
+4 | |     #[derive(PartialEq, Eq)]
+  | |                         -- first implementation here
+5 | |     struct Flags: u32 {
+6 | |         const A = 0b00000001;
+7 | |     }
+8 | | }
+  | |_^ conflicting implementation for `Flags`
+  |
+  = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs
new file mode 100644
index 000000000..c2856b108
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs
@@ -0,0 +1,123 @@
+use std::{
+    fmt::{
+        self,
+        Debug,
+        Display,
+        LowerHex,
+        UpperHex,
+        Octal,
+        Binary,
+    },
+    ops::{
+        BitAnd,
+        BitOr,
+        BitXor,
+        BitAndAssign,
+        BitOrAssign,
+        BitXorAssign,
+        Not,
+    },
+};
+
+use bitflags::bitflags;
+
+// Ideally we'd actually want this to work, but currently need something like `num`'s `Zero`
+// With some design work it could be made possible
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct MyInt(u8);
+
+impl BitAnd for MyInt {
+    type Output = Self;
+
+    fn bitand(self, other: Self) -> Self {
+        MyInt(self.0 & other.0)
+    }
+}
+
+impl BitOr for MyInt {
+    type Output = Self;
+
+    fn bitor(self, other: Self) -> Self {
+        MyInt(self.0 | other.0)
+    }
+}
+
+impl BitXor for MyInt {
+    type Output = Self;
+
+    fn bitxor(self, other: Self) -> Self {
+        MyInt(self.0 ^ other.0)
+    }
+}
+
+impl BitAndAssign for MyInt {
+    fn bitand_assign(&mut self, other: Self) {
+        self.0 &= other.0
+    }
+}
+
+impl BitOrAssign for MyInt {
+    fn bitor_assign(&mut self, other: Self) {
+        self.0 |= other.0
+    }
+}
+
+impl BitXorAssign for MyInt {
+    fn bitxor_assign(&mut self, other: Self) {
+        self.0 ^= other.0
+    }
+}
+
+impl Debug for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+impl Display for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl LowerHex for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        LowerHex::fmt(&self.0, f)
+    }
+}
+
+impl UpperHex for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        UpperHex::fmt(&self.0, f)
+    }
+}
+
+impl Octal for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Octal::fmt(&self.0, f)
+    }
+}
+
+impl Binary for MyInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Binary::fmt(&self.0, f)
+    }
+}
+
+impl Not for MyInt {
+    type Output = MyInt;
+
+    fn not(self) -> Self {
+        MyInt(!self.0)
+    }
+}
+
+bitflags! {
+    struct Flags128: MyInt {
+        const A = MyInt(0b0000_0001u8);
+        const B = MyInt(0b0000_0010u8);
+        const C = MyInt(0b0000_0100u8);
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta
new file mode 100644
index 000000000..1f0fb5cf7
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta
@@ -0,0 +1,27 @@
+error[E0308]: mismatched types
+   --> $DIR/all_defined.rs:115:1
+    |
+115 | / bitflags! {
+116 | |     struct Flags128: MyInt {
+117 | |         const A = MyInt(0b0000_0001u8);
+118 | |         const B = MyInt(0b0000_0010u8);
+119 | |         const C = MyInt(0b0000_0100u8);
+120 | |     }
+121 | | }
+    | |_^ expected struct `MyInt`, found integer
+    |
+    = note: this error originates in the macro `__impl_all_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+   --> $DIR/all_defined.rs:115:1
+    |
+115 | / bitflags! {
+116 | |     struct Flags128: MyInt {
+117 | |         const A = MyInt(0b0000_0001u8);
+118 | |         const B = MyInt(0b0000_0010u8);
+119 | |         const C = MyInt(0b0000_0100u8);
+120 | |     }
+121 | | }
+    | |_^ expected struct `MyInt`, found integer
+    |
+    = note: this error originates in the macro `__impl_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs
new file mode 100644
index 000000000..fff6b2cc1
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs
@@ -0,0 +1,13 @@
+use bitflags::bitflags;
+
+struct MyInt(u8);
+
+bitflags! {
+    struct Flags128: MyInt {
+        const A = MyInt(0b0000_0001);
+        const B = MyInt(0b0000_0010);
+        const C = MyInt(0b0000_0100);
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta
new file mode 100644
index 000000000..ee95f8365
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta
@@ -0,0 +1,13 @@
+error[E0204]: the trait `Copy` may not be implemented for this type
+  --> $DIR/all_missing.rs:5:1
+   |
+5  | / bitflags! {
+6  | |     struct Flags128: MyInt {
+7  | |         const A = MyInt(0b0000_0001);
+8  | |         const B = MyInt(0b0000_0010);
+9  | |         const C = MyInt(0b0000_0100);
+10 | |     }
+11 | | }
+   | |_^ this field does not implement `Copy`
+   |
+   = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_field.rs b/vendor/bitflags/tests/compile-fail/visibility/private_field.rs
new file mode 100644
index 000000000..a6a3912ae
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/private_field.rs
@@ -0,0 +1,13 @@
+mod example {
+    use bitflags::bitflags;
+
+    bitflags! {
+        pub struct Flags1: u32 {
+            const FLAG_A = 0b00000001;
+        }
+    }
+}
+
+fn main() {
+    let flag1 = example::Flags1::FLAG_A.bits;
+}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta
new file mode 100644
index 000000000..58a046601
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta
@@ -0,0 +1,10 @@
+error[E0616]: field `bits` of struct `Flags1` is private
+  --> $DIR/private_field.rs:12:41
+   |
+12 |     let flag1 = example::Flags1::FLAG_A.bits;
+   |                                         ^^^^ private field
+   |
+help: a method `bits` also exists, call it with parentheses
+   |
+12 |     let flag1 = example::Flags1::FLAG_A.bits();
+   |                                             ^^
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs b/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs
new file mode 100644
index 000000000..85a5b1863
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs
@@ -0,0 +1,18 @@
+mod example {
+    use bitflags::bitflags;
+
+    bitflags! {
+        pub struct Flags1: u32 {
+            const FLAG_A = 0b00000001;
+        }
+
+        struct Flags2: u32 {
+            const FLAG_B = 0b00000010;
+        }
+    }
+}
+
+fn main() {
+    let flag1 = example::Flags1::FLAG_A;
+    let flag2 = example::Flags2::FLAG_B;
+}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta
new file mode 100644
index 000000000..d23f83209
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta
@@ -0,0 +1,18 @@
+error[E0603]: struct `Flags2` is private
+  --> $DIR/private_flags.rs:17:26
+   |
+17 |     let flag2 = example::Flags2::FLAG_B;
+   |                          ^^^^^^ private struct
+   |
+note: the struct `Flags2` is defined here
+  --> $DIR/private_flags.rs:4:5
+   |
+4  | /     bitflags! {
+5  | |         pub struct Flags1: u32 {
+6  | |             const FLAG_A = 0b00000001;
+7  | |         }
+...  |
+11 | |         }
+12 | |     }
+   | |_____^
+   = note: this error originates in the macro `bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs b/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs
new file mode 100644
index 000000000..b90f0ce92
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs
@@ -0,0 +1,9 @@
+use bitflags::bitflags;
+
+bitflags! {
+    pub struct Flags1: u32 {
+        pub const FLAG_A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta
new file mode 100644
index 000000000..b01122c7a
--- /dev/null
+++ b/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta
@@ -0,0 +1,5 @@
+error: no rules expected the token `pub`
+ --> $DIR/pub_const.rs:5:9
+  |
+5 |         pub const FLAG_A = 0b00000001;
+  |         ^^^ no rules expected this token in macro call
diff --git a/vendor/bitflags/tests/compile-pass/impls/convert.rs b/vendor/bitflags/tests/compile-pass/impls/convert.rs
new file mode 100644
index 000000000..1f02982a8
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/impls/convert.rs
@@ -0,0 +1,17 @@
+use bitflags::bitflags;
+
+bitflags! {
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+impl From<u32> for Flags {
+    fn from(v: u32) -> Flags {
+        Flags::from_bits_truncate(v)
+    }
+}
+
+fn main() {
+
+}
diff --git a/vendor/bitflags/tests/compile-pass/impls/default.rs b/vendor/bitflags/tests/compile-pass/impls/default.rs
new file mode 100644
index 000000000..a97b6536f
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/impls/default.rs
@@ -0,0 +1,10 @@
+use bitflags::bitflags;
+
+bitflags! {
+    #[derive(Default)]
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs b/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs
new file mode 100644
index 000000000..3052c460e
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs
@@ -0,0 +1,15 @@
+use bitflags::bitflags;
+
+bitflags! {
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+impl Flags {
+    pub fn new() -> Flags {
+        Flags::A
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/redefinition/core.rs b/vendor/bitflags/tests/compile-pass/redefinition/core.rs
new file mode 100644
index 000000000..475492159
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/redefinition/core.rs
@@ -0,0 +1,14 @@
+use bitflags::bitflags;
+
+// Checks for possible errors caused by overriding names used by `bitflags!` internally.
+
+mod core {}
+mod _core {}
+
+bitflags! {
+    struct Test: u8 {
+        const A = 1;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs b/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs
new file mode 100644
index 000000000..b04f2f6a4
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs
@@ -0,0 +1,19 @@
+use bitflags::bitflags;
+
+// Checks for possible errors caused by overriding names used by `bitflags!` internally.
+
+#[allow(unused_macros)]
+macro_rules! stringify {
+    ($($t:tt)*) => { "..." };
+}
+
+bitflags! {
+    struct Test: u8 {
+        const A = 1;
+    }
+}
+
+fn main() {
+    // Just make sure we don't call the redefined `stringify` macro
+    assert_eq!(format!("{:?}", Test::A), "A");
+}
diff --git a/vendor/bitflags/tests/compile-pass/repr/c.rs b/vendor/bitflags/tests/compile-pass/repr/c.rs
new file mode 100644
index 000000000..6feba36ed
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/repr/c.rs
@@ -0,0 +1,10 @@
+use bitflags::bitflags;
+
+bitflags! {
+    #[repr(C)]
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/repr/transparent.rs b/vendor/bitflags/tests/compile-pass/repr/transparent.rs
new file mode 100644
index 000000000..e38db4dd1
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/repr/transparent.rs
@@ -0,0 +1,10 @@
+use bitflags::bitflags;
+
+bitflags! {
+    #[repr(transparent)]
+    struct Flags: u32 {
+        const A = 0b00000001;
+    }
+}
+
+fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs b/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs
new file mode 100644
index 000000000..33a7967e6
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs
@@ -0,0 +1,11 @@
+use bitflags::bitflags;
+
+bitflags! {
+    pub struct Flags1: u32 {
+        const FLAG_A = 0b00000001;
+    }
+}
+
+fn main() {
+    assert_eq!(0b00000001, Flags1::FLAG_A.bits);
+}
diff --git a/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs b/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs
new file mode 100644
index 000000000..c11050e3b
--- /dev/null
+++ b/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs
@@ -0,0 +1,19 @@
+mod a {
+    mod b {
+        use bitflags::bitflags;
+
+        bitflags! {
+            pub(in crate::a) struct Flags: u32 {
+                const FLAG_A = 0b00000001;
+            }
+        }
+    }
+
+    pub fn flags() -> u32 {
+        b::Flags::FLAG_A.bits()
+    }
+}
+
+fn main() {
+    assert_eq!(0b00000001, a::flags());
+}
diff --git a/vendor/bitflags/tests/compile.rs b/vendor/bitflags/tests/compile.rs
new file mode 100644
index 000000000..ed02d01e9
--- /dev/null
+++ b/vendor/bitflags/tests/compile.rs
@@ -0,0 +1,63 @@
+use std::{
+    fs,
+    ffi::OsStr,
+    io,
+    path::Path,
+};
+
+use walkdir::WalkDir;
+
+#[test]
+fn fail() {
+    prepare_stderr_files("tests/compile-fail").unwrap();
+
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/compile-fail/**/*.rs");
+}
+
+#[test]
+fn pass() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/compile-pass/**/*.rs");
+}
+
+// Compiler messages may change between versions
+// We don't want to have to track these too closely for `bitflags`, but
+// having some message to check makes sure user-facing errors are sensical.
+// 
+// The approach we use is to run the test on all compilers, but only check stderr
+// output on beta (which is the next stable release). We do this by default ignoring
+// any `.stderr` files in the `compile-fail` directory, and copying `.stderr.beta` files
+// when we happen to be running on a beta compiler.
+fn prepare_stderr_files(path: impl AsRef<Path>) -> io::Result<()> {
+    for entry in WalkDir::new(path) {
+        let entry = entry?;
+
+        if entry.path().extension().and_then(OsStr::to_str) == Some("beta") {
+            let renamed = entry.path().with_extension("");
+
+            // Unconditionally remove a corresponding `.stderr` file for a `.stderr.beta`
+            // file if it exists. On `beta` compilers, we'll recreate it. On other compilers,
+            // we don't want to end up checking it anyways.
+            if renamed.exists() {
+                fs::remove_file(&renamed)?;
+            }
+
+            rename_beta_stderr(entry.path(), renamed)?;
+        }
+    }
+
+    Ok(())
+}
+
+#[rustversion::beta]
+fn rename_beta_stderr(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
+    fs::copy(from, to)?;
+
+    Ok(())
+}
+
+#[rustversion::not(beta)]
+fn rename_beta_stderr(_: impl AsRef<Path>, _: impl AsRef<Path>) -> io::Result<()> {
+    Ok(())
+}