unused 0.1.0

Allows for unused generic parameters that do not act like they are owned.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

extern crate std;

use std::cell::UnsafeCell;
use std::marker::PhantomPinned;
use std::panic::{RefUnwindSafe, UnwindSafe};
use std::prelude::v1::*;
use std::rc::Rc;

use crate::Unused;

#[test]
fn variance() {
    fn _simple_covariant<'a>(
        unused: Unused!(&'static str: covariant),
    ) -> Unused!(&'a str: covariant,) {
        unused
    }

    fn _covariant_and_invariant<'a>(
        unused: Unused!(u8: invariant, &'static u16: covariant, &'a str: invariant),
    ) -> Unused!(u8: invariant, &'a u16: covariant, &'a str: invariant) {
        unused
    }

    fn _covariant_and_contravariant<'a>(
        unused: Unused!(&'a str: contravariant, &'static str: covariant,),
    ) -> Unused!(&'static str: contravariant, &'a str: covariant) {
        unused
    }
}

#[test]
fn auto_traits() {
    fn auto_traits_are_implemented<T: Send + Sync + Unpin + UnwindSafe + RefUnwindSafe>() {}

    auto_traits_are_implemented::<
        Unused!(Rc<str>: covariant, UnsafeCell<i32>, PhantomPinned: contravariant,),
    >()
}

#[test]
fn macro_used_as_value() {
    struct Foo<T> {
        #[allow(dead_code)]
        unused: Unused!(T),
    }

    let _ = Foo {
        unused: Unused!(u8),
    };
}

/// ```compile_fail
/// use unused::Unused;
///
/// fn invariant<'a>(
///     unused: Unused!(&'static str),
/// ) -> Unused!(&'a str) {
///     unused
/// }
/// ```
pub fn _invariant_not_covariant() {}

/// ```compile_fail
/// use unused::Unused;
///
/// fn invariant<'a>(
///     unused: Unused!(&'a str: invariant),
/// ) -> Unused!(&'static str: invariant) {
///     unused
/// }
/// ```
pub fn _invariant_not_contravariant() {}