#![cfg_attr(not(feature = "std"), no_std)]
#![allow(dead_code)]
#[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(not(feature = "std"))]
use alloc::{
borrow::Cow,
borrow::ToOwned,
boxed::Box,
string::{String, ToString},
};
use core::mem;
#[cfg(feature = "std")]
use std::borrow::Cow;
use derive_more::Into;
use static_assertions::assert_not_impl_any;
unsafe fn transmute<From, To>(from: From) -> To {
let to = unsafe { mem::transmute_copy(&from) };
mem::forget(from);
to
}
#[derive(Debug, PartialEq)]
#[repr(transparent)]
struct Wrapped<T>(T);
#[derive(Debug, PartialEq)]
#[repr(transparent)]
struct Transmuted<T>(T);
impl<T> From<Wrapped<T>> for Transmuted<T> {
fn from(from: Wrapped<T>) -> Self {
unsafe { transmute(from) }
}
}
impl<T> From<&Wrapped<T>> for &Transmuted<T> {
fn from(from: &Wrapped<T>) -> Self {
unsafe { transmute(from) }
}
}
impl<T> From<&mut Wrapped<T>> for &mut Transmuted<T> {
fn from(from: &mut Wrapped<T>) -> Self {
unsafe { transmute(from) }
}
}
mod unit {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Unit;
#[derive(Debug, Into, PartialEq)]
struct Tuple();
#[derive(Debug, Into, PartialEq)]
struct Struct {}
#[test]
fn assert() {
assert_eq!((), Unit.into());
assert_eq!((), Tuple().into());
assert_eq!((), Struct {}.into());
}
mod generic {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Unit<const N: usize>;
#[derive(Debug, Into, PartialEq)]
struct Tuple<const N: usize>();
#[derive(Debug, Into, PartialEq)]
struct Struct<const N: usize> {}
#[test]
fn assert() {
assert_eq!((), Unit::<1>.into());
assert_eq!((), Tuple::<1>().into());
assert_eq!((), Struct::<1> {}.into());
}
}
}
mod single_field {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple(i32);
#[derive(Debug, Into, PartialEq)]
struct Struct {
field: i32,
}
#[test]
fn assert() {
assert_eq!(42, Tuple(42).into());
assert_eq!(42, Struct { field: 42 }.into());
}
mod skip {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple(#[into(skip)] i32);
#[derive(Debug, Into, PartialEq)]
struct Struct {
#[into(skip)]
field: i32,
}
#[test]
fn assert() {
assert_eq!((), Tuple(42).into());
assert_eq!((), Struct { field: 42 }.into());
}
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(i64)]
#[into(i128)]
struct Tuple(i32);
#[derive(Debug, Into, PartialEq)]
#[into(Box<str>, Cow<'_, str>)]
struct Struct {
field: String,
}
#[test]
fn assert() {
assert_not_impl_any!(Tuple: Into<i32>);
assert_not_impl_any!(Struct: Into<String>);
assert_eq!(42_i64, Tuple(42).into());
assert_eq!(42_i128, Tuple(42).into());
assert_eq!(
Box::<str>::from("42".to_owned()),
Struct {
field: "42".to_string(),
}
.into(),
);
assert_eq!(
Cow::Borrowed("42"),
Cow::<str>::from(Struct {
field: "42".to_string(),
}),
);
}
mod ref_ {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Unnamed(i32);
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Named {
field: i32,
}
#[test]
fn assert() {
assert_eq!(&42, <&i32>::from(&Unnamed(42)));
assert_eq!(&42, <&i32>::from(&Named { field: 42 }));
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref(i32, Unnamed))]
struct Tuple(Unnamed);
#[derive(Debug, Into, PartialEq)]
#[into(ref(i32, Named))]
struct Struct {
field: Named,
}
#[test]
fn assert() {
assert_eq!(&42, <&i32>::from(&Tuple(Unnamed(42))));
assert_eq!(&Unnamed(42), <&Unnamed>::from(&Tuple(Unnamed(42))));
assert_eq!(
&42,
<&i32>::from(&Struct {
field: Named { field: 42 },
}),
);
assert_eq!(
&Named { field: 42 },
<&Named>::from(&Struct {
field: Named { field: 42 },
}),
);
}
}
}
mod ref_mut {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Unnamed(i32);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Named {
field: i32,
}
#[test]
fn assert() {
assert_eq!(&mut 42, <&mut i32>::from(&mut Unnamed(42)));
assert_eq!(&mut 42, <&mut i32>::from(&mut Named { field: 42 }));
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(i32, Unnamed))]
struct Tuple(Unnamed);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(i32, Named))]
struct Struct {
field: Named,
}
#[test]
fn assert() {
assert_eq!(&mut 42, <&mut i32>::from(&mut Tuple(Unnamed(42))));
assert_eq!(
&mut Unnamed(42),
<&mut Unnamed>::from(&mut Tuple(Unnamed(42))),
);
assert_eq!(
&mut 42,
<&mut i32>::from(&mut Struct {
field: Named { field: 42 },
}),
);
assert_eq!(
&mut Named { field: 42 },
<&mut Named>::from(&mut Struct {
field: Named { field: 42 },
}),
);
}
}
}
}
mod generic {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(Wrapped(42), Tuple(Wrapped(42)).into());
assert_eq!(Wrapped(42), Struct { field: Wrapped(42) }.into());
}
mod skip {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<T>(#[into(skip)] Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
struct Struct<T> {
#[into(skip)]
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!((), Tuple(Wrapped(42)).into());
assert_eq!((), Struct { field: Wrapped(42) }.into());
}
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(Transmuted<T>)]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
#[into(Transmuted<T>)]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(Transmuted(42), Tuple(Wrapped(42)).into());
assert_eq!(Transmuted(42), Struct { field: Wrapped(42) }.into());
}
}
mod ref_ {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(&Wrapped(42), <&Wrapped<_>>::from(&Tuple(Wrapped(42))));
assert_eq!(
&Wrapped(42),
<&Wrapped<_>>::from(&Struct { field: Wrapped(42) })
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref(Transmuted<T>))]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
#[into(ref(Transmuted<T>))]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(
&Transmuted(42),
<&Transmuted<_>>::from(&Tuple(Wrapped(42))),
);
assert_eq!(
&Transmuted(42),
<&Transmuted<_>>::from(&Struct { field: Wrapped(42) }),
);
}
}
}
mod ref_mut {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(
&mut Wrapped(42),
<&mut Wrapped<_>>::from(&mut Tuple(Wrapped(42)))
);
assert_eq!(
&mut Wrapped(42),
<&mut Wrapped<_>>::from(&mut Struct { field: Wrapped(42) }),
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(Transmuted<T>))]
struct Tuple<T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(Transmuted<T>))]
struct Struct<T> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(
&mut Transmuted(42),
<&mut Transmuted<_>>::from(&mut Tuple(Wrapped(42))),
);
assert_eq!(
&mut Transmuted(42),
<&mut Transmuted<_>>::from(&mut Struct { field: Wrapped(42) }),
);
}
}
}
mod indirect {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<T: 'static>(&'static Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
struct Struct<T: 'static> {
field: &'static Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(&Wrapped(42), <&Wrapped<_>>::from(Tuple(&Wrapped(42))));
assert_eq!(
&Wrapped(42),
<&Wrapped<_>>::from(Struct {
field: &Wrapped(42),
}),
);
}
}
mod bounded {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<T: Clone>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
struct Struct<T: Clone> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(Wrapped(42), Tuple(Wrapped(42)).into());
assert_eq!(Wrapped(42), Struct { field: Wrapped(42) }.into());
}
}
mod r#const {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<const N: usize, T>(Wrapped<T>);
#[derive(Debug, Into, PartialEq)]
struct Struct<T, const N: usize> {
field: Wrapped<T>,
}
#[test]
fn assert() {
assert_eq!(Wrapped(1), Tuple::<1, _>(Wrapped(1)).into());
assert_eq!(Wrapped(1), Struct::<_, 1> { field: Wrapped(1) }.into());
}
}
}
}
mod multi_field {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple(i32, i64);
#[derive(Debug, Into, PartialEq)]
struct Struct {
field1: i32,
field2: i64,
}
#[test]
fn assert() {
assert_eq!((1, 2_i64), Tuple(1, 2_i64).into());
assert_eq!(
(1, 2_i64),
Struct {
field1: 1,
field2: 2_i64,
}
.into(),
);
}
mod skip {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple(i32, #[into(skip)] i64);
#[derive(Debug, Into, PartialEq)]
struct Struct {
#[into(skip)]
field1: i32,
field2: i64,
}
#[test]
fn assert() {
assert_eq!(1, Tuple(1, 2_i64).into());
assert_eq!(
2_i64,
Struct {
field1: 1,
field2: 2_i64,
}
.into(),
);
}
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into((i32, i64))]
#[into((i64, i128))]
struct Tuple(i16, i32);
#[derive(Debug, Into, PartialEq)]
#[into((Box<str>, i32), (Cow<'_, str>, i64))]
struct Struct {
field1: String,
field2: i32,
}
#[test]
fn assert() {
assert_not_impl_any!(Tuple: Into<(i16, i32)>);
assert_not_impl_any!(Struct: Into<(String, i32)>);
assert_eq!((1, 2_i64), Tuple(1_i16, 2).into());
assert_eq!((1_i64, 2_i128), Tuple(1_i16, 2).into());
assert_eq!(
(Box::<str>::from("42".to_owned()), 1),
Struct {
field1: "42".to_string(),
field2: 1,
}
.into(),
);
assert_eq!(
(Cow::Borrowed("42"), 1_i64),
Struct {
field1: "42".to_string(),
field2: 1,
}
.into(),
);
}
mod ref_ {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Unnamed(i32, i64);
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Named {
field1: i32,
field2: i64,
}
#[test]
fn assert() {
assert_eq!((&1, &2_i64), (&Unnamed(1, 2_i64)).into());
assert_eq!(
(&1, &2_i64),
(&Named {
field1: 1,
field2: 2_i64,
})
.into(),
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref(
(Transmuted<i32>, Transmuted<i64>),
(Transmuted<i32>, Wrapped<i64>)),
)]
struct Tuple(Wrapped<i32>, Wrapped<i64>);
#[derive(Debug, Into, PartialEq)]
#[into(ref(
(Transmuted<i32>, Transmuted<i64>),
(Transmuted<i32>, Wrapped<i64>)),
)]
struct Struct {
field1: Wrapped<i32>,
field2: Wrapped<i64>,
}
#[test]
fn assert() {
assert_eq!(
(&Transmuted(1), &Transmuted(2_i64)),
(&Tuple(Wrapped(1), Wrapped(2_i64))).into(),
);
assert_eq!(
(&Transmuted(1), &Wrapped(2_i64)),
(&Tuple(Wrapped(1), Wrapped(2_i64))).into(),
);
assert_eq!(
(&Transmuted(1), &Transmuted(2_i64)),
(&Struct {
field1: Wrapped(1),
field2: Wrapped(2_i64),
})
.into(),
);
assert_eq!(
(&Transmuted(1), &Wrapped(2_i64)),
(&Struct {
field1: Wrapped(1),
field2: Wrapped(2_i64),
})
.into(),
);
}
}
}
mod ref_mut {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Unnamed(i32, i64);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Named {
field1: i32,
field2: i64,
}
#[test]
fn assert() {
assert_eq!((&mut 1, &mut 2_i64), (&mut Unnamed(1, 2_i64)).into());
assert_eq!(
(&mut 1, &mut 2_i64),
(&mut Named {
field1: 1,
field2: 2_i64,
})
.into(),
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(
(Transmuted<i32>, Transmuted<i64>),
(Transmuted<i32>, Wrapped<i64>)),
)]
struct Tuple(Wrapped<i32>, Wrapped<i64>);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut(
(Transmuted<i32>, Transmuted<i64>),
(Transmuted<i32>, Wrapped<i64>)),
)]
struct Struct {
field1: Wrapped<i32>,
field2: Wrapped<i64>,
}
#[test]
fn assert() {
assert_eq!(
(&mut Transmuted(1), &mut Transmuted(2_i64)),
(&mut Tuple(Wrapped(1), Wrapped(2_i64))).into(),
);
assert_eq!(
(&mut Transmuted(1), &mut Wrapped(2_i64)),
(&mut Tuple(Wrapped(1), Wrapped(2_i64))).into(),
);
assert_eq!(
(&mut Transmuted(1), &mut Transmuted(2_i64)),
(&mut Struct {
field1: Wrapped(1),
field2: Wrapped(2_i64),
})
.into(),
);
assert_eq!(
(&mut Transmuted(1), &mut Wrapped(2_i64)),
(&mut Struct {
field1: Wrapped(1),
field2: Wrapped(2_i64),
})
.into(),
);
}
}
}
}
mod generic {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(Wrapped(1), Wrapped(2)),
Tuple(Wrapped(1), Wrapped(2)).into(),
);
assert_eq!(
(Wrapped(1), Wrapped(2)),
Struct {
field1: Wrapped(1),
field2: Wrapped(2),
}
.into(),
);
}
mod skip {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<A, B>(Wrapped<A>, #[into(skip)] Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
struct Struct<A, B> {
#[into(skip)]
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(Wrapped(1), Tuple(Wrapped(1), Wrapped(2)).into());
assert_eq!(
Wrapped(2),
Struct {
field1: Wrapped(1),
field2: Wrapped(2),
}
.into(),
);
}
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into((Transmuted<A>, Transmuted<B>))]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
#[into((Transmuted<A>, Transmuted<B>))]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(Transmuted(1), Transmuted(2)),
Tuple(Wrapped(1), Wrapped(2)).into(),
);
assert_eq!(
(Transmuted(1), Transmuted(2)),
Struct {
field1: Wrapped(1),
field2: Wrapped(2),
}
.into(),
);
}
}
mod ref_ {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
#[into(ref)]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(&Wrapped(1), &Wrapped(2)),
(&Tuple(Wrapped(1), Wrapped(2))).into(),
);
assert_eq!(
(&Wrapped(1), &Wrapped(2)),
(&Struct {
field1: Wrapped(1),
field2: Wrapped(2),
})
.into(),
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref((Transmuted<A>, Transmuted<B>)))]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
#[into(ref((Transmuted<A>, Transmuted<B>)))]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(&Transmuted(1), &Transmuted(2)),
(&Tuple(Wrapped(1), Wrapped(2))).into(),
);
assert_eq!(
(&Transmuted(1), &Transmuted(2)),
(&Struct {
field1: Wrapped(1),
field2: Wrapped(2),
})
.into(),
);
}
}
}
mod ref_mut {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut)]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(&mut Wrapped(1), &mut Wrapped(2)),
(&mut Tuple(Wrapped(1), Wrapped(2))).into(),
);
assert_eq!(
(&mut Wrapped(1), &mut Wrapped(2)),
(&mut Struct {
field1: Wrapped(1),
field2: Wrapped(2),
})
.into(),
);
}
mod types {
use super::*;
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut((Transmuted<A>, Transmuted<B>)))]
struct Tuple<A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
#[into(ref_mut((Transmuted<A>, Transmuted<B>)))]
struct Struct<A, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(&mut Transmuted(1), &mut Transmuted(2)),
(&mut Tuple(Wrapped(1), Wrapped(2))).into(),
);
assert_eq!(
(&mut Transmuted(1), &mut Transmuted(2)),
(&mut Struct {
field1: Wrapped(1),
field2: Wrapped(2),
})
.into(),
);
}
}
}
mod indirect {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<A: 'static, B: 'static>(
&'static Wrapped<A>,
&'static Wrapped<B>,
);
#[derive(Debug, Into, PartialEq)]
struct Struct<A: 'static, B: 'static> {
field1: &'static Wrapped<A>,
field2: &'static Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(&Wrapped(1), &Wrapped(2)),
Tuple(&Wrapped(1), &Wrapped(2)).into(),
);
assert_eq!(
(&Wrapped(1), &Wrapped(2)),
(Struct {
field1: &Wrapped(1),
field2: &Wrapped(2),
})
.into(),
);
}
}
mod bounded {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<A: Clone, B: Clone>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
struct Struct<A: Clone, B: Clone> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(Wrapped(1), Wrapped(2)),
Tuple(Wrapped(1), Wrapped(2)).into(),
);
assert_eq!(
(Wrapped(1), Wrapped(2)),
Struct {
field1: Wrapped(1),
field2: Wrapped(2),
}
.into(),
);
}
}
mod r#const {
use super::*;
#[derive(Debug, Into, PartialEq)]
struct Tuple<const N: usize, A, B>(Wrapped<A>, Wrapped<B>);
#[derive(Debug, Into, PartialEq)]
struct Struct<A, const N: usize, B> {
field1: Wrapped<A>,
field2: Wrapped<B>,
}
#[test]
fn assert() {
assert_eq!(
(Wrapped(1), Wrapped(2)),
Tuple::<1, _, _>(Wrapped(1), Wrapped(2)).into(),
);
assert_eq!(
(Wrapped(1), Wrapped(2)),
Struct::<_, 1, _> {
field1: Wrapped(1),
field2: Wrapped(2),
}
.into(),
);
}
}
}
}