port to meson cargoHEADmasterfeature/port-to-meson-cargo

Use the new unstable meson cargo support. This simplifies the
meson.build script and allows to use crates such as clap that require
picking up features from Cargo.toml.

This also allows us to not embed thiserror in subprojects, and instead
use a wrap file with a custom meson.build and some patches to make it
compile without running its build.rs script.

1 files changed, 0 insertions, 478 deletions

diff --git a/subprojects/thiserror/tests/test_display.rs b/subprojects/thiserror/tests/test_display.rs
deleted file mode 100644
index cace226..0000000
--- a/subprojects/thiserror/tests/test_display.rs
+++ /dev/null
@@ -1,478 +0,0 @@
-#![allow(
-    clippy::elidable_lifetime_names,
-    clippy::needless_lifetimes,
-    clippy::needless_raw_string_hashes,
-    clippy::trivially_copy_pass_by_ref,
-    clippy::uninlined_format_args
-)]
-
-use core::fmt::{self, Display};
-use thiserror::Error;
-
-fn assert<T: Display>(expected: &str, value: T) {
-    assert_eq!(expected, value.to_string());
-}
-
-#[test]
-fn test_braced() {
-    #[derive(Error, Debug)]
-    #[error("braced error: {msg}")]
-    struct Error {
-        msg: String,
-    }
-
-    let msg = "T".to_owned();
-    assert("braced error: T", Error { msg });
-}
-
-#[test]
-fn test_braced_unused() {
-    #[derive(Error, Debug)]
-    #[error("braced error")]
-    struct Error {
-        extra: usize,
-    }
-
-    assert("braced error", Error { extra: 0 });
-}
-
-#[test]
-fn test_tuple() {
-    #[derive(Error, Debug)]
-    #[error("tuple error: {0}")]
-    struct Error(usize);
-
-    assert("tuple error: 0", Error(0));
-}
-
-#[test]
-fn test_unit() {
-    #[derive(Error, Debug)]
-    #[error("unit error")]
-    struct Error;
-
-    assert("unit error", Error);
-}
-
-#[test]
-fn test_enum() {
-    #[derive(Error, Debug)]
-    enum Error {
-        #[error("braced error: {id}")]
-        Braced { id: usize },
-        #[error("tuple error: {0}")]
-        Tuple(usize),
-        #[error("unit error")]
-        Unit,
-    }
-
-    assert("braced error: 0", Error::Braced { id: 0 });
-    assert("tuple error: 0", Error::Tuple(0));
-    assert("unit error", Error::Unit);
-}
-
-#[test]
-fn test_constants() {
-    #[derive(Error, Debug)]
-    #[error("{MSG}: {id:?} (code {CODE:?})")]
-    struct Error {
-        id: &'static str,
-    }
-
-    const MSG: &str = "failed to do";
-    const CODE: usize = 9;
-
-    assert("failed to do: \"\" (code 9)", Error { id: "" });
-}
-
-#[test]
-fn test_inherit() {
-    #[derive(Error, Debug)]
-    #[error("{0}")]
-    enum Error {
-        Some(&'static str),
-        #[error("other error")]
-        Other(&'static str),
-    }
-
-    assert("some error", Error::Some("some error"));
-    assert("other error", Error::Other("..."));
-}
-
-#[test]
-fn test_brace_escape() {
-    #[derive(Error, Debug)]
-    #[error("fn main() {{}}")]
-    struct Error;
-
-    assert("fn main() {}", Error);
-}
-
-#[test]
-fn test_expr() {
-    #[derive(Error, Debug)]
-    #[error("1 + 1 = {}", 1 + 1)]
-    struct Error;
-    assert("1 + 1 = 2", Error);
-}
-
-#[test]
-fn test_nested() {
-    #[derive(Error, Debug)]
-    #[error("!bool = {}", not(.0))]
-    struct Error(bool);
-
-    #[allow(clippy::trivially_copy_pass_by_ref)]
-    fn not(bool: &bool) -> bool {
-        !*bool
-    }
-
-    assert("!bool = false", Error(true));
-}
-
-#[test]
-fn test_match() {
-    #[derive(Error, Debug)]
-    #[error("{intro}: {0}", intro = match .1 {
-        Some(n) => format!("error occurred with {}", n),
-        None => "there was an empty error".to_owned(),
-    })]
-    struct Error(String, Option<usize>);
-
-    assert(
-        "error occurred with 1: ...",
-        Error("...".to_owned(), Some(1)),
-    );
-    assert(
-        "there was an empty error: ...",
-        Error("...".to_owned(), None),
-    );
-}
-
-#[test]
-fn test_nested_display() {
-    // Same behavior as the one in `test_match`, but without String allocations.
-    #[derive(Error, Debug)]
-    #[error("{}", {
-        struct Msg<'a>(&'a String, &'a Option<usize>);
-        impl<'a> Display for Msg<'a> {
-            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                match self.1 {
-                    Some(n) => write!(formatter, "error occurred with {}", n),
-                    None => write!(formatter, "there was an empty error"),
-                }?;
-                write!(formatter, ": {}", self.0)
-            }
-        }
-        Msg(.0, .1)
-    })]
-    struct Error(String, Option<usize>);
-
-    assert(
-        "error occurred with 1: ...",
-        Error("...".to_owned(), Some(1)),
-    );
-    assert(
-        "there was an empty error: ...",
-        Error("...".to_owned(), None),
-    );
-}
-
-#[test]
-fn test_void() {
-    #[allow(clippy::empty_enums)]
-    #[derive(Error, Debug)]
-    #[error("...")]
-    pub enum Error {}
-
-    let _: Error;
-}
-
-#[test]
-fn test_mixed() {
-    #[derive(Error, Debug)]
-    #[error("a={a} :: b={} :: c={c} :: d={d}", 1, c = 2, d = 3)]
-    struct Error {
-        a: usize,
-        d: usize,
-    }
-
-    assert("a=0 :: b=1 :: c=2 :: d=3", Error { a: 0, d: 0 });
-}
-
-#[test]
-fn test_ints() {
-    #[derive(Error, Debug)]
-    enum Error {
-        #[error("error {0}")]
-        Tuple(usize, usize),
-        #[error("error {0}", '?')]
-        Struct { v: usize },
-    }
-
-    assert("error 9", Error::Tuple(9, 0));
-    assert("error ?", Error::Struct { v: 0 });
-}
-
-#[test]
-fn test_trailing_comma() {
-    #[derive(Error, Debug)]
-    #[error(
-        "error {0}",
-    )]
-    #[rustfmt::skip]
-    struct Error(char);
-
-    assert("error ?", Error('?'));
-}
-
-#[test]
-fn test_field() {
-    #[derive(Debug)]
-    struct Inner {
-        data: usize,
-    }
-
-    #[derive(Error, Debug)]
-    #[error("{}", .0.data)]
-    struct Error(Inner);
-
-    assert("0", Error(Inner { data: 0 }));
-}
-
-#[test]
-fn test_nested_tuple_field() {
-    #[derive(Debug)]
-    struct Inner(usize);
-
-    #[derive(Error, Debug)]
-    #[error("{}", .0.0)]
-    struct Error(Inner);
-
-    assert("0", Error(Inner(0)));
-}
-
-#[test]
-fn test_pointer() {
-    #[derive(Error, Debug)]
-    #[error("{field:p}")]
-    pub struct Struct {
-        field: Box<i32>,
-    }
-
-    let s = Struct {
-        field: Box::new(-1),
-    };
-    assert_eq!(s.to_string(), format!("{:p}", s.field));
-}
-
-#[test]
-fn test_macro_rules_variant_from_call_site() {
-    // Regression test for https://github.com/dtolnay/thiserror/issues/86
-
-    macro_rules! decl_error {
-        ($variant:ident($value:ident)) => {
-            #[derive(Error, Debug)]
-            pub enum Error0 {
-                #[error("{0:?}")]
-                $variant($value),
-            }
-
-            #[derive(Error, Debug)]
-            #[error("{0:?}")]
-            pub enum Error1 {
-                $variant($value),
-            }
-        };
-    }
-
-    decl_error!(Repro(u8));
-
-    assert("0", Error0::Repro(0));
-    assert("0", Error1::Repro(0));
-}
-
-#[test]
-fn test_macro_rules_message_from_call_site() {
-    // Regression test for https://github.com/dtolnay/thiserror/issues/398
-
-    macro_rules! decl_error {
-        ($($errors:tt)*) => {
-            #[derive(Error, Debug)]
-            pub enum Error {
-                $($errors)*
-            }
-        };
-    }
-
-    decl_error! {
-        #[error("{0}")]
-        Unnamed(u8),
-        #[error("{x}")]
-        Named { x: u8 },
-    }
-
-    assert("0", Error::Unnamed(0));
-    assert("0", Error::Named { x: 0 });
-}
-
-#[test]
-fn test_raw() {
-    #[derive(Error, Debug)]
-    #[error("braced raw error: {fn}")]
-    struct Error {
-        r#fn: &'static str,
-    }
-
-    assert("braced raw error: T", Error { r#fn: "T" });
-}
-
-#[test]
-fn test_raw_enum() {
-    #[derive(Error, Debug)]
-    enum Error {
-        #[error("braced raw error: {fn}")]
-        Braced { r#fn: &'static str },
-    }
-
-    assert("braced raw error: T", Error::Braced { r#fn: "T" });
-}
-
-#[test]
-fn test_keyword() {
-    #[derive(Error, Debug)]
-    #[error("error: {type}", type = 1)]
-    struct Error;
-
-    assert("error: 1", Error);
-}
-
-#[test]
-fn test_self() {
-    #[derive(Error, Debug)]
-    #[error("error: {self:?}")]
-    struct Error;
-
-    assert("error: Error", Error);
-}
-
-#[test]
-fn test_str_special_chars() {
-    #[derive(Error, Debug)]
-    pub enum Error {
-        #[error("brace left {{")]
-        BraceLeft,
-        #[error("brace left 2 \x7B\x7B")]
-        BraceLeft2,
-        #[error("brace left 3 \u{7B}\u{7B}")]
-        BraceLeft3,
-        #[error("brace right }}")]
-        BraceRight,
-        #[error("brace right 2 \x7D\x7D")]
-        BraceRight2,
-        #[error("brace right 3 \u{7D}\u{7D}")]
-        BraceRight3,
-        #[error(
-            "new_\
-line"
-        )]
-        NewLine,
-        #[error("escape24 \u{78}")]
-        Escape24,
-    }
-
-    assert("brace left {", Error::BraceLeft);
-    assert("brace left 2 {", Error::BraceLeft2);
-    assert("brace left 3 {", Error::BraceLeft3);
-    assert("brace right }", Error::BraceRight);
-    assert("brace right 2 }", Error::BraceRight2);
-    assert("brace right 3 }", Error::BraceRight3);
-    assert("new_line", Error::NewLine);
-    assert("escape24 x", Error::Escape24);
-}
-
-#[test]
-fn test_raw_str() {
-    #[derive(Error, Debug)]
-    pub enum Error {
-        #[error(r#"raw brace left {{"#)]
-        BraceLeft,
-        #[error(r#"raw brace left 2 \x7B"#)]
-        BraceLeft2,
-        #[error(r#"raw brace right }}"#)]
-        BraceRight,
-        #[error(r#"raw brace right 2 \x7D"#)]
-        BraceRight2,
-    }
-
-    assert(r#"raw brace left {"#, Error::BraceLeft);
-    assert(r#"raw brace left 2 \x7B"#, Error::BraceLeft2);
-    assert(r#"raw brace right }"#, Error::BraceRight);
-    assert(r#"raw brace right 2 \x7D"#, Error::BraceRight2);
-}
-
-mod util {
-    use core::fmt::{self, Octal};
-
-    pub fn octal<T: Octal>(value: &T, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "0o{:o}", value)
-    }
-}
-
-#[test]
-fn test_fmt_path() {
-    fn unit(formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("unit=")
-    }
-
-    fn pair(k: &i32, v: &i32, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "pair={k}:{v}")
-    }
-
-    #[derive(Error, Debug)]
-    pub enum Error {
-        #[error(fmt = unit)]
-        Unit,
-        #[error(fmt = pair)]
-        Tuple(i32, i32),
-        #[error(fmt = pair)]
-        Entry { k: i32, v: i32 },
-        #[error(fmt = crate::util::octal)]
-        I16(i16),
-        #[error(fmt = crate::util::octal::<i32>)]
-        I32 { n: i32 },
-        #[error(fmt = core::fmt::Octal::fmt)]
-        I64(i64),
-        #[error("...{0}")]
-        Other(bool),
-    }
-
-    assert("unit=", Error::Unit);
-    assert("pair=10:0", Error::Tuple(10, 0));
-    assert("pair=10:0", Error::Entry { k: 10, v: 0 });
-    assert("0o777", Error::I16(0o777));
-    assert("0o777", Error::I32 { n: 0o777 });
-    assert("777", Error::I64(0o777));
-    assert("...false", Error::Other(false));
-}
-
-#[test]
-fn test_fmt_path_inherited() {
-    #[derive(Error, Debug)]
-    #[error(fmt = crate::util::octal)]
-    pub enum Error {
-        I16(i16),
-        I32 {
-            n: i32,
-        },
-        #[error(fmt = core::fmt::Octal::fmt)]
-        I64(i64),
-        #[error("...{0}")]
-        Other(bool),
-    }
-
-    assert("0o777", Error::I16(0o777));
-    assert("0o777", Error::I32 { n: 0o777 });
-    assert("777", Error::I64(0o777));
-    assert("...false", Error::Other(false));
-}