#![warn(missing_docs_in_private_items)]
#![allow(dead_code)]
#![feature(associated_type_defaults)]
#![doc="More garbage"]
type Typedef = String;
pub type PubTypedef = String;
struct Foo {
a: isize,
b: isize,
}
pub struct PubFoo {
pub a: isize,
b: isize,
}
#[allow(missing_docs_in_private_items)]
pub struct PubFoo2 {
pub a: isize,
pub c: isize,
}
mod module_no_dox {}
pub mod pub_module_no_dox {}
pub fn foo() {}
pub fn foo2() {}
fn foo3() {}
#[allow(missing_docs_in_private_items)] pub fn foo4() {}
pub trait A {
fn foo(&self);
fn foo_with_impl(&self) {}
}
#[allow(missing_docs_in_private_items)]
trait B {
fn foo(&self);
fn foo_with_impl(&self) {}
}
pub trait C {
fn foo(&self);
fn foo_with_impl(&self) {}
}
#[allow(missing_docs_in_private_items)]
pub trait D {
fn dummy(&self) { }
}
pub trait E {
type AssociatedType;
type AssociatedTypeDef = Self;
type DocumentedType;
type DocumentedTypeDef = Self;
fn dummy(&self) {}
}
impl Foo {
pub fn foo() {}
fn bar() {}
}
impl PubFoo {
pub fn foo() {}
pub fn foo1() {}
fn foo2() {}
#[allow(missing_docs_in_private_items)] pub fn foo3() {}
}
#[allow(missing_docs_in_private_items)]
trait F {
fn a();
fn b(&self);
}
impl F for Foo {
fn a() {}
fn b(&self) {}
}
#[doc(hidden)]
mod a {
pub fn baz() {}
pub mod b {
pub fn baz() {}
}
}
enum Baz {
BazA {
a: isize,
b: isize
},
BarB
}
pub enum PubBaz {
PubBazA {
a: isize,
},
}
pub enum PubBaz2 {
PubBaz2A {
a: isize,
},
}
#[allow(missing_docs_in_private_items)]
pub enum PubBaz3 {
PubBaz3A {
b: isize
},
}
#[doc(hidden)]
pub fn baz() {}
const FOO: u32 = 0;
pub const FOO1: u32 = 0;
#[allow(missing_docs_in_private_items)]
pub const FOO2: u32 = 0;
#[doc(hidden)]
pub const FOO3: u32 = 0;
pub const FOO4: u32 = 0;
static BAR: u32 = 0;
pub static BAR1: u32 = 0;
#[allow(missing_docs_in_private_items)]
pub static BAR2: u32 = 0;
#[doc(hidden)]
pub static BAR3: u32 = 0;
pub static BAR4: u32 = 0;
mod internal_impl {
pub fn documented() {}
pub fn undocumented1() {}
pub fn undocumented2() {}
fn undocumented3() {}
pub mod globbed {
pub fn also_documented() {}
pub fn also_undocumented1() {}
fn also_undocumented2() {}
}
}
pub mod public_interface {
pub use internal_impl::documented as foo;
pub use internal_impl::undocumented1 as bar;
pub use internal_impl::{documented, undocumented2};
pub use internal_impl::globbed::*;
}
fn main() {}