mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-04 20:54:13 +00:00
203 lines
3.6 KiB
Rust
203 lines
3.6 KiB
Rust
/* This file incorporates work covered by the following copyright and
|
|
* permission notice:
|
|
* Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
* file at the top-level directory of this distribution and at
|
|
* http://rust-lang.org/COPYRIGHT.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
* http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
* <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
* option. This file may not be copied, modified, or distributed
|
|
* except according to those terms.
|
|
*/
|
|
|
|
|
|
|
|
#![warn(missing_docs_in_private_items)]
|
|
|
|
// When denying at the crate level, be sure to not get random warnings from the
|
|
// injected intrinsics by the compiler.
|
|
#![allow(dead_code)]
|
|
#![feature(associated_type_defaults)]
|
|
|
|
//! Some garbage docs for the crate here
|
|
#![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 {}
|
|
|
|
/// dox
|
|
pub fn foo() {}
|
|
pub fn foo2() {}
|
|
fn foo3() {}
|
|
#[allow(missing_docs_in_private_items)] pub fn foo4() {}
|
|
|
|
/// dox
|
|
pub trait A {
|
|
/// dox
|
|
fn foo(&self);
|
|
/// dox
|
|
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) { }
|
|
}
|
|
|
|
/// dox
|
|
pub trait E {
|
|
type AssociatedType;
|
|
type AssociatedTypeDef = Self;
|
|
|
|
/// dox
|
|
type DocumentedType;
|
|
/// dox
|
|
type DocumentedTypeDef = Self;
|
|
/// dox
|
|
fn dummy(&self) {}
|
|
}
|
|
|
|
impl Foo {
|
|
pub fn foo() {}
|
|
fn bar() {}
|
|
}
|
|
|
|
impl PubFoo {
|
|
pub fn foo() {}
|
|
/// dox
|
|
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);
|
|
}
|
|
|
|
// should need to redefine documentation for implementations of traits
|
|
impl F for Foo {
|
|
fn a() {}
|
|
fn b(&self) {}
|
|
}
|
|
|
|
// It sure is nice if doc(hidden) implies allow(missing_docs), and that it
|
|
// applies recursively
|
|
#[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,
|
|
},
|
|
}
|
|
|
|
/// dox
|
|
pub enum PubBaz2 {
|
|
/// dox
|
|
PubBaz2A {
|
|
/// dox
|
|
a: isize,
|
|
},
|
|
}
|
|
|
|
#[allow(missing_docs_in_private_items)]
|
|
pub enum PubBaz3 {
|
|
PubBaz3A {
|
|
b: isize
|
|
},
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub fn baz() {}
|
|
|
|
|
|
const FOO: u32 = 0;
|
|
/// dox
|
|
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;
|
|
/// dox
|
|
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 {
|
|
/// dox
|
|
pub fn documented() {}
|
|
pub fn undocumented1() {}
|
|
pub fn undocumented2() {}
|
|
fn undocumented3() {}
|
|
/// dox
|
|
pub mod globbed {
|
|
/// dox
|
|
pub fn also_documented() {}
|
|
pub fn also_undocumented1() {}
|
|
fn also_undocumented2() {}
|
|
}
|
|
}
|
|
/// dox
|
|
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() {}
|