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
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! A public module that is always included in the crate.

/// A public struct that is always included in the crate.
#[cfg_attr(feature = "copy", derive(Copy))]
pub struct A {
    /// A public field that is always included in the crate.
    pub a: u8,

    #[cfg(feature = "foo")]
    /// A public field that is only included in the crate with feature `foo`.
    pub foo: u8,

    #[cfg(all(feature = "foo", feature = "bar"))]
    /// A public field that is only included in the crate with features `foo` and `bar`.
    pub foobar: u8,
}

/// A public function that is always included in the crate.
pub fn a() {
}

#[cfg(feature = "foo")]
/// A public function that is only included in the crate with feature `foo`.
pub fn foo() {
}

#[cfg(all(feature = "foo", feature = "bar"))]
/// A public function that is only included in the crate with features `foo` and `bar`.
pub fn foobar() {
}

/// A public trait that is always included in the crate.
pub trait ATrait {
    #[cfg(feature = "foo")]
    /// A trait method that is only included in the crate with feature `foo`.
    fn foo(&self) {
    }

    #[cfg(all(feature = "foo", feature = "bar"))]
    /// A trait method that is only included in the crate with features `foo` and `bar`.
    fn foobar(&self) {
    }
}

#[cfg(feature = "foo")]
/// A public trait that is only included in the crate with feature `foo`.
pub trait FooTrait {
    /// A trait method that is always included in the crate.
    /// (if the parent trait is)
    fn foo(&self) {
    }

    #[cfg(feature = "bar")]
    /// A trait method that is only included in the crate with feature `bar`.
    /// (if the parent trait is)
    fn foobar(&self) {
    }
}

#[cfg(all(feature = "foo", feature = "bar"))]
/// A public trait that is only included in the crate with features `foo` and `bar`.
pub trait FooBarTrait {
    /// A trait method impl that is always included in the crate.
    /// (if the parent trait is)
    fn foo(&self) {
    }

    /// A trait method impl that is always included in the crate.
    /// (if the parent trait is)
    fn foobar(&self) {
    }
}

/// Some impls (from `a`) that are always included in the crate.
impl A {
    /// A public method that is always included in the crate.
    pub fn a(&self) {
    }

    #[cfg(feature = "foo")]
    /// A public method that is only included in the crate with feature `foo`.
    pub fn foo(&self) {
    }

    #[cfg(all(feature = "foo", feature = "bar"))]
    /// A public method that is only included in the crate with features `foo` and `bar`.
    pub fn foobar2(&self) {
    }
}

/// A trait impl that is always included in the crate.
impl ATrait for A {
    #[cfg(feature = "foo")]
    /// A trait method impl that is only included in the crate with feature `foo`.
    fn foo(&self) {
    }

    #[cfg(all(feature = "foo", feature = "bar"))]
    /// A trait method impl that is only included in the crate with features `foo` and `bar`.
    fn foobar(&self) {
    }
}

#[cfg(feature = "foo")]
/// A trait impl that is only included in the crate with feature `foo`.
impl FooTrait for A {
    /// A trait method impl that is always included in the crate.
    /// (if the parent trait is)
    fn foo(&self) {
    }

    #[cfg(feature = "bar")]
    /// A trait method impl that is only included in the crate with feature `bar`.
    /// (if the parent trait is)
    fn foobar(&self) {
    }
}

#[cfg(all(feature = "foo", feature = "bar"))]
/// A trait impl that is only included in the crate with features `foo` and `bar`.
impl FooBarTrait for A {
    /// A trait method impl that is always included in the crate.
    /// (if the parent trait is)
    fn foo(&self) {
    }

    /// A trait method impl that is always included in the crate.
    /// (if the parent trait is)
    fn foobar(&self) {
    }
}