#[deriving(Clone, Encodable, Decodable)]
pub struct Crate {
- name: ~str,
- module: Option<Item>,
- externs: Vec<(ast::CrateNum, ExternalCrate)> ,
+ pub name: ~str,
+ pub module: Option<Item>,
+ pub externs: Vec<(ast::CrateNum, ExternalCrate)>,
}
impl<'a> Clean<Crate> for visit_ast::RustdocVisitor<'a> {
#[deriving(Clone, Encodable, Decodable)]
pub struct ExternalCrate {
- name: ~str,
- attrs: Vec<Attribute> ,
+ pub name: ~str,
+ pub attrs: Vec<Attribute>,
}
impl Clean<ExternalCrate> for cstore::crate_metadata {
#[deriving(Clone, Encodable, Decodable)]
pub struct Item {
/// Stringified span
- source: Span,
+ pub source: Span,
/// Not everything has a name. E.g., impls
- name: Option<~str>,
- attrs: Vec<Attribute> ,
- inner: ItemEnum,
- visibility: Option<Visibility>,
- id: ast::NodeId,
+ pub name: Option<~str>,
+
pub attrs: Vec<Attribute> ,
+ pub inner: ItemEnum,
+ pub visibility: Option<Visibility>,
+ pub id: ast::NodeId,
}
impl Item {
#[deriving(Clone, Encodable, Decodable)]
pub struct Module {
- items: Vec<Item> ,
- is_crate: bool,
+ pub items: Vec<Item>,
+ pub is_crate: bool,
}
impl Clean<Item> for doctree::Module {
#[deriving(Clone, Encodable, Decodable)]
pub struct TyParam {
- name: ~str,
- id: ast::NodeId,
- bounds: Vec<TyParamBound> }
+ pub name: ~str,
+ pub id: ast::NodeId,
+ pub bounds: Vec<TyParamBound>,
+}
impl Clean<TyParam> for ast::TyParam {
fn clean(&self) -> TyParam {
// maybe use a Generic enum and use ~[Generic]?
#[deriving(Clone, Encodable, Decodable)]
pub struct Generics {
- lifetimes: Vec<Lifetime> ,
- type_params: Vec<TyParam> }
+ pub lifetimes: Vec<Lifetime>,
+ pub type_params: Vec<TyParam>,
+}
impl Clean<Generics> for ast::Generics {
fn clean(&self) -> Generics {
#[deriving(Clone, Encodable, Decodable)]
pub struct Method {
- generics: Generics,
- self_: SelfTy,
- purity: ast::Purity,
- decl: FnDecl,
+ pub generics: Generics,
+ pub self_: SelfTy,
+ pub purity: ast::Purity,
+ pub decl: FnDecl,
}
impl Clean<Item> for ast::Method {
#[deriving(Clone, Encodable, Decodable)]
pub struct TyMethod {
- purity: ast::Purity,
- decl: FnDecl,
- generics: Generics,
- self_: SelfTy,
+ pub purity: ast::Purity,
+ pub decl: FnDecl,
+ pub generics: Generics,
+ pub self_: SelfTy,
}
impl Clean<Item> for ast::TypeMethod {
#[deriving(Clone, Encodable, Decodable)]
pub struct Function {
- decl: FnDecl,
- generics: Generics,
- purity: ast::Purity,
+ pub decl: FnDecl,
+ pub generics: Generics,
+ pub purity: ast::Purity,
}
impl Clean<Item> for doctree::Function {
#[deriving(Clone, Encodable, Decodable)]
pub struct ClosureDecl {
- sigil: ast::Sigil,
- region: Option<Lifetime>,
- lifetimes: Vec<Lifetime> ,
- decl: FnDecl,
- onceness: ast::Onceness,
- purity: ast::Purity,
- bounds: Vec<TyParamBound> }
+ pub sigil: ast::Sigil,
+ pub region: Option<Lifetime>,
+ pub lifetimes: Vec<Lifetime>,
+ pub decl: FnDecl,
+ pub onceness: ast::Onceness,
+ pub purity: ast::Purity,
+ pub bounds: Vec<TyParamBound>,
+}
impl Clean<ClosureDecl> for ast::ClosureTy {
fn clean(&self) -> ClosureDecl {
#[deriving(Clone, Encodable, Decodable)]
pub struct FnDecl {
- inputs: Arguments,
- output: Type,
- cf: RetStyle,
- attrs: Vec<Attribute> }
+ pub inputs: Arguments,
+ pub output: Type,
+ pub cf: RetStyle,
+ pub attrs: Vec<Attribute>,
+}
#[deriving(Clone, Encodable, Decodable)]
pub struct Arguments {
- values: Vec<Argument> ,
+ pub values: Vec<Argument>,
}
impl Clean<FnDecl> for ast::FnDecl {
#[deriving(Clone, Encodable, Decodable)]
pub struct Argument {
- type_: Type,
- name: ~str,
- id: ast::NodeId
+ pub type_: Type,
+ pub name: ~str,
+ pub id: ast::NodeId,
}
impl Clean<Argument> for ast::Arg {
#[deriving(Clone, Encodable, Decodable)]
pub struct Trait {
- methods: Vec<TraitMethod> ,
- generics: Generics,
- parents: Vec<Type> ,
+ pub methods: Vec<TraitMethod>,
+ pub generics: Generics,
+ pub parents: Vec<Type>,
}
impl Clean<Item> for doctree::Trait {
pub enum Type {
/// structs/enums/traits (anything that'd be an ast::TyPath)
ResolvedPath {
- path: Path,
- typarams: Option<Vec<TyParamBound> >,
- id: ast::NodeId,
+ pub path: Path,
+ pub typarams: Option<Vec<TyParamBound>>,
+ pub id: ast::NodeId,
},
/// Same as above, but only external variants
ExternalPath {
- path: Path,
- typarams: Option<Vec<TyParamBound> >,
- fqn: Vec<~str> ,
- kind: TypeKind,
- krate: ast::CrateNum,
+ pub path: Path,
+ pub typarams: Option<Vec<TyParamBound>>,
+ pub fqn: Vec<~str>,
+ pub kind: TypeKind,
+ pub krate: ast::CrateNum,
},
// I have no idea how to usefully use this.
TyParamBinder(ast::NodeId),
Unique(~Type),
Managed(~Type),
RawPointer(Mutability, ~Type),
- BorrowedRef { lifetime: Option<Lifetime>, mutability: Mutability, type_: ~Type},
+ BorrowedRef {
+ pub lifetime: Option<Lifetime>,
+ pub mutability: Mutability,
+ pub type_: ~Type,
+ },
// region, raw, other boxes, mutable
}
#[deriving(Clone, Encodable, Decodable)]
pub struct StructField {
- type_: Type,
+ pub type_: Type,
}
impl Clean<Item> for ast::StructField {
#[deriving(Clone, Encodable, Decodable)]
pub struct Struct {
- struct_type: doctree::StructType,
- generics: Generics,
- fields: Vec<Item> ,
- fields_stripped: bool,
+ pub struct_type: doctree::StructType,
+ pub generics: Generics,
+ pub fields: Vec<Item>,
+ pub fields_stripped: bool,
}
impl Clean<Item> for doctree::Struct {
/// only as a variant in an enum.
#[deriving(Clone, Encodable, Decodable)]
pub struct VariantStruct {
- struct_type: doctree::StructType,
- fields: Vec<Item> ,
- fields_stripped: bool,
+ pub struct_type: doctree::StructType,
+ pub fields: Vec<Item>,
+ pub fields_stripped: bool,
}
impl Clean<VariantStruct> for syntax::ast::StructDef {
#[deriving(Clone, Encodable, Decodable)]
pub struct Enum {
- variants: Vec<Item> ,
- generics: Generics,
- variants_stripped: bool,
+ pub variants: Vec<Item>,
+ pub generics: Generics,
+ pub variants_stripped: bool,
}
impl Clean<Item> for doctree::Enum {
#[deriving(Clone, Encodable, Decodable)]
pub struct Variant {
- kind: VariantKind,
+ pub kind: VariantKind,
}
impl Clean<Item> for doctree::Variant {
#[deriving(Clone, Encodable, Decodable)]
pub struct Span {
- filename: ~str,
- loline: uint,
- locol: uint,
- hiline: uint,
- hicol: uint,
+ pub filename: ~str,
+ pub loline: uint,
+ pub locol: uint,
+ pub hiline: uint,
+ pub hicol: uint,
}
impl Clean<Span> for syntax::codemap::Span {
#[deriving(Clone, Encodable, Decodable)]
pub struct Path {
- global: bool,
- segments: Vec<PathSegment> ,
+ pub global: bool,
+ pub segments: Vec<PathSegment>,
}
impl Clean<Path> for ast::Path {
#[deriving(Clone, Encodable, Decodable)]
pub struct PathSegment {
- name: ~str,
- lifetimes: Vec<Lifetime> ,
- types: Vec<Type> ,
+ pub name: ~str,
+ pub lifetimes: Vec<Lifetime>,
+ pub types: Vec<Type>,
}
impl Clean<PathSegment> for ast::PathSegment {
#[deriving(Clone, Encodable, Decodable)]
pub struct Typedef {
- type_: Type,
- generics: Generics,
+ pub type_: Type,
+ pub generics: Generics,
}
impl Clean<Item> for doctree::Typedef {
#[deriving(Clone, Encodable, Decodable)]
pub struct BareFunctionDecl {
- purity: ast::Purity,
- generics: Generics,
- decl: FnDecl,
- abi: ~str
+ pub purity: ast::Purity,
+ pub generics: Generics,
+ pub decl: FnDecl,
+ pub abi: ~str,
}
impl Clean<BareFunctionDecl> for ast::BareFnTy {
#[deriving(Clone, Encodable, Decodable)]
pub struct Static {
- type_: Type,
- mutability: Mutability,
+ pub type_: Type,
+ pub mutability: Mutability,
/// It's useful to have the value of a static documented, but I have no
/// desire to represent expressions (that'd basically be all of the AST,
/// which is huge!). So, have a string.
- expr: ~str,
+ pub expr: ~str,
}
impl Clean<Item> for doctree::Static {
#[deriving(Clone, Encodable, Decodable)]
pub struct Impl {
- generics: Generics,
- trait_: Option<Type>,
- for_: Type,
- methods: Vec<Item>,
- derived: bool,
+ pub generics: Generics,
+ pub trait_: Option<Type>,
+ pub for_: Type,
+ pub methods: Vec<Item>,
+ pub derived: bool,
}
impl Clean<Item> for doctree::Impl {
#[deriving(Clone, Encodable, Decodable)]
pub struct ViewItem {
- inner: ViewItemInner
+ pub inner: ViewItemInner,
}
impl Clean<Item> for ast::ViewItem {
#[deriving(Clone, Encodable, Decodable)]
pub struct ImportSource {
- path: Path,
- did: Option<ast::DefId>,
+ pub path: Path,
+
pub did: Option<ast::DefId>,
}
impl Clean<ViewPath> for ast::ViewPath {
#[deriving(Clone, Encodable, Decodable)]
pub struct ViewListIdent {
- name: ~str,
- source: Option<ast::DefId>,
+ pub name: ~str,
+
pub source: Option<ast::DefId>,
}
impl Clean<ViewListIdent> for ast::PathListIdent {
#[deriving(Clone, Encodable, Decodable)]
pub struct Macro {
- source: ~str,
+ pub source: ~str,
}
impl Clean<Item> for doctree::Macro {
}
pub struct DocContext {
- krate: ast::Crate,
- maybe_typed: MaybeTyped
+ pub krate: ast::Crate,
+ pub maybe_typed: MaybeTyped
}
impl DocContext {
}
pub struct CrateAnalysis {
- exported_items: privacy::ExportedItems,
- public_items: privacy::PublicItems,
+ pub exported_items: privacy::ExportedItems,
+ pub public_items: privacy::PublicItems,
}
/// Parses, resolves, and typechecks the given crate
use syntax::ast::{Ident, NodeId};
pub struct Module {
- name: Option<Ident>,
- attrs: Vec<ast::Attribute> ,
- where: Span,
- structs: Vec<Struct> ,
- enums: Vec<Enum> ,
- fns: Vec<Function> ,
- mods: Vec<Module> ,
- id: NodeId,
- typedefs: Vec<Typedef> ,
- statics: Vec<Static> ,
- traits: Vec<Trait> ,
- vis: ast::Visibility,
- impls: Vec<Impl> ,
- foreigns: Vec<ast::ForeignMod> ,
- view_items: Vec<ast::ViewItem> ,
- macros: Vec<Macro> ,
- is_crate: bool,
+ pub name: Option<Ident>,
+ pub attrs: Vec<ast::Attribute>,
+ pub where: Span,
+ pub structs: Vec<Struct>,
+ pub enums: Vec<Enum>,
+ pub fns: Vec<Function>,
+ pub mods: Vec<Module>,
+ pub id: NodeId,
+ pub typedefs: Vec<Typedef>,
+ pub statics: Vec<Static>,
+ pub traits: Vec<Trait>,
+ pub vis: ast::Visibility,
+ pub impls: Vec<Impl>,
+ pub foreigns: Vec<ast::ForeignMod>,
+ pub view_items: Vec<ast::ViewItem>,
+ pub macros: Vec<Macro>,
+ pub is_crate: bool,
}
impl Module {
}
pub struct Struct {
- vis: ast::Visibility,
- id: NodeId,
- struct_type: StructType,
- name: Ident,
- generics: ast::Generics,
- attrs: Vec<ast::Attribute> ,
- fields: Vec<ast::StructField> ,
- where: Span,
+ pub vis: ast::Visibility,
+ pub id: NodeId,
+ pub struct_type: StructType,
+ pub name: Ident,
+ pub generics: ast::Generics,
+ pub attrs: Vec<ast::Attribute>,
+ pub fields: Vec<ast::StructField>,
+ pub where: Span,
}
pub struct Enum {
- vis: ast::Visibility,
- variants: Vec<Variant> ,
- generics: ast::Generics,
- attrs: Vec<ast::Attribute> ,
- id: NodeId,
- where: Span,
- name: Ident,
+ pub vis: ast::Visibility,
+ pub variants: Vec<Variant>,
+ pub generics: ast::Generics,
+ pub attrs: Vec<ast::Attribute>,
+ pub id: NodeId,
+ pub where: Span,
+ pub name: Ident,
}
pub struct Variant {
- name: Ident,
- attrs: Vec<ast::Attribute> ,
- kind: ast::VariantKind,
- id: ast::NodeId,
- vis: ast::Visibility,
- where: Span,
+ pub name: Ident,
+ pub attrs: Vec<ast::Attribute>,
+ pub kind: ast::VariantKind,
+ pub id: ast::NodeId,
+ pub vis: ast::Visibility,
+ pub where: Span,
}
pub struct Function {
- decl: ast::FnDecl,
- attrs: Vec<ast::Attribute> ,
- id: NodeId,
- name: Ident,
- vis: ast::Visibility,
- purity: ast::Purity,
- where: Span,
- generics: ast::Generics,
+ pub decl: ast::FnDecl,
+ pub attrs: Vec<ast::Attribute>,
+ pub id: NodeId,
+ pub name: Ident,
+ pub vis: ast::Visibility,
+ pub purity: ast::Purity,
+ pub where: Span,
+ pub generics: ast::Generics,
}
pub struct Typedef {
- ty: ast::P<ast::Ty>,
- gen: ast::Generics,
- name: Ident,
- id: ast::NodeId,
- attrs: Vec<ast::Attribute> ,
- where: Span,
- vis: ast::Visibility,
+
pub ty: ast::P<ast::Ty>,
+ pub gen: ast::Generics,
+ pub name: Ident,
+ pub id: ast::NodeId,
+ pub attrs: Vec<ast::Attribute>,
+ pub where: Span,
+ pub vis: ast::Visibility,
}
pub struct Static {
- type_: ast::P<ast::Ty>,
- mutability: ast::Mutability,
- expr: @ast::Expr,
- name: Ident,
- attrs: Vec<ast::Attribute> ,
- vis: ast::Visibility,
- id: ast::NodeId,
- where: Span,
+
pub type_: ast::P<ast::Ty>,
+ pub mutability: ast::Mutability,
+ pub expr: @ast::Expr,
+ pub name: Ident,
+ pub attrs: Vec<ast::Attribute>,
+ pub vis: ast::Visibility,
+ pub id: ast::NodeId,
+ pub where: Span,
}
pub struct Trait {
- name: Ident,
- methods: Vec<ast::TraitMethod> , //should be TraitMethod
- generics: ast::Generics,
- parents: Vec<ast::TraitRef> ,
- attrs: Vec<ast::Attribute> ,
- id: ast::NodeId,
- where: Span,
- vis: ast::Visibility,
+ pub name: Ident,
+ pub methods: Vec<ast::TraitMethod>, //should be TraitMethod
+ pub generics: ast::Generics,
+ pub parents: Vec<ast::TraitRef>,
+ pub attrs: Vec<ast::Attribute>,
+ pub id: ast::NodeId,
+ pub where: Span,
+ pub vis: ast::Visibility,
}
pub struct Impl {
- generics: ast::Generics,
- trait_: Option<ast::TraitRef>,
- for_: ast::P<ast::Ty>,
- methods: Vec<@ast::Method> ,
- attrs: Vec<ast::Attribute> ,
- where: Span,
- vis: ast::Visibility,
- id: ast::NodeId,
+ pub generics: ast::Generics,
+
pub trait_: Option<ast::TraitRef>,
+
pub for_: ast::P<ast::Ty>,
+ pub methods: Vec<@ast::Method>,
+ pub attrs: Vec<ast::Attribute>,
+ pub where: Span,
+ pub vis: ast::Visibility,
+ pub id: ast::NodeId,
}
pub struct Macro {
- name: Ident,
- id: ast::NodeId,
- attrs: Vec<ast::Attribute> ,
- where: Span,
+ pub name: Ident,
+ pub id: ast::NodeId,
+ pub attrs: Vec<ast::Attribute>,
+ pub where: Span,
}
pub fn struct_type_from_def(sd: &ast::StructDef) -> StructType {
use std::libc;
pub struct flock {
- l_type: libc::c_short,
- l_whence: libc::c_short,
- l_start: libc::off_t,
- l_len: libc::off_t,
- l_pid: libc::pid_t,
+ pub l_type: libc::c_short,
+ pub l_whence: libc::c_short,
+ pub l_start: libc::off_t,
+ pub l_len: libc::off_t,
+ pub l_pid: libc::pid_t,
// not actually here, but brings in line with freebsd
- l_sysid: libc::c_int,
+ pub l_sysid: libc::c_int,
}
pub static F_WRLCK: libc::c_short = 1;
use std::libc;
pub struct flock {
- l_start: libc::off_t,
- l_len: libc::off_t,
- l_pid: libc::pid_t,
- l_type: libc::c_short,
- l_whence: libc::c_short,
- l_sysid: libc::c_int,
+ pub l_start: libc::off_t,
+ pub l_len: libc::off_t,
+ pub l_pid: libc::pid_t,
+ pub l_type: libc::c_short,
+ pub l_whence: libc::c_short,
+ pub l_sysid: libc::c_int,
}
pub static F_UNLCK: libc::c_short = 2;
use std::libc;
pub struct flock {
- l_start: libc::off_t,
- l_len: libc::off_t,
- l_pid: libc::pid_t,
- l_type: libc::c_short,
- l_whence: libc::c_short,
+ pub l_start: libc::off_t,
+ pub l_len: libc::off_t,
+ pub l_pid: libc::pid_t,
+ pub l_type: libc::c_short,
+ pub l_whence: libc::c_short,
// not actually here, but brings in line with freebsd
- l_sysid: libc::c_int,
+ pub l_sysid: libc::c_int,
}
pub static F_UNLCK: libc::c_short = 2;
}
pub struct Lock {
- priv fd: libc::c_int,
+ fd: libc::c_int,
}
impl Lock {
}
pub struct Lock {
- priv handle: libc::HANDLE,
+ handle: libc::HANDLE,
}
impl Lock {
#[deriving(Clone)]
pub struct Layout {
- logo: ~str,
- favicon: ~str,
- krate: ~str,
+ pub logo: ~str,
+ pub favicon: ~str,
+ pub krate: ~str,
}
pub struct Page<'a> {
- title: &'a str,
- ty: &'a str,
- root_path: &'a str,
+ pub title: &'a str,
+ pub ty: &'a str,
+ pub root_path: &'a str,
}
pub fn render<T: fmt::Show, S: fmt::Show>(
pub struct Context {
/// Current hierarchy of components leading down to what's currently being
/// rendered
- current: Vec<~str> ,
+ pub current: Vec<~str> ,
/// String representation of how to get back to the root path of the 'doc/'
/// folder in terms of a relative URL.
- root_path: ~str,
+ pub root_path: ~str,
/// The current destination folder of where HTML artifacts should be placed.
/// This changes as the context descends into the module hierarchy.
- dst: Path,
+ pub dst: Path,
/// This describes the layout of each page, and is not modified after
/// creation of the context (contains info like the favicon)
- layout: layout::Layout,
+ pub layout: layout::Layout,
/// This map is a list of what should be displayed on the sidebar of the
/// current page. The key is the section header (traits, modules,
/// functions), and the value is the list of containers belonging to this
/// header. This map will change depending on the surrounding context of the
/// page.
- sidebar: HashMap<~str, Vec<~str> >,
+ pub sidebar: HashMap<~str, Vec<~str> >,
/// This flag indicates whether [src] links should be generated or not. If
/// the source files are present in the html rendering, then this will be
/// `true`.
- include_sources: bool,
+ pub include_sources: bool,
}
/// Indicates where an external crate can be found.
/// Mapping of typaram ids to the name of the type parameter. This is used
/// when pretty-printing a type (so pretty printing doesn't have to
/// painfully maintain a context like this)
- typarams: HashMap<ast::NodeId, ~str>,
+
pub typarams: HashMap<ast::NodeId, ~str>,
/// Maps a type id to all known implementations for that type. This is only
/// recognized for intra-crate `ResolvedPath` types, and is used to print
///
/// The values of the map are a list of implementations and documentation
/// found on that implementation.
- impls: HashMap<ast::NodeId, Vec<(clean::Impl, Option<~str>)> >,
+
pub impls: HashMap<ast::NodeId, Vec<(clean::Impl, Option<~str>)> >,
/// Maintains a mapping of local crate node ids to the fully qualified name
/// and "short type description" of that node. This is used when generating
/// URLs when a type is being linked to. External paths are not located in
/// this map because the `External` type itself has all the information
/// necessary.
- paths: HashMap<ast::NodeId, (Vec<~str> , &'static str)>,
+ p
ub paths: HashMap<ast::NodeId, (Vec<~str> , &'static str)>,
/// This map contains information about all known traits of this crate.
/// Implementations of a crate should inherit the documentation of the
/// parent trait if no extra documentation is specified, and default methods
/// should show up in documentation about trait implementations.
- traits: HashMap<ast::NodeId, clean::Trait>,
+
pub traits: HashMap<ast::NodeId, clean::Trait>,
/// When rendering traits, it's often useful to be able to list all
/// implementors of the trait, and this mapping is exactly, that: a mapping
/// of trait ids to the list of known implementors of the trait
- implementors: HashMap<ast::NodeId, Vec<Implementor> >,
+
pub implementors: HashMap<ast::NodeId, Vec<Implementor> >,
/// Cache of where external crate documentation can be found.
- extern_locations: HashMap<ast::CrateNum, ExternalLocation>,
+
pub extern_locations: HashMap<ast::CrateNum, ExternalLocation>,
// Private fields only used when initially crawling a crate to build a cache
- priv stack: Vec<~str> ,
- p
riv parent_stack: Vec<ast::NodeId> ,
- priv search_index: Vec<IndexItem> ,
- priv privmod: bool,
- priv public_items: NodeSet,
+ stack: Vec<~str> ,
+ parent_stack: Vec<ast::NodeId> ,
+ search_index: Vec<IndexItem> ,
+ privmod: bool,
+ public_items: NodeSet,
// In rare case where a structure is defined in one module but implemented
// in another, if the implementing module is parsed before defining module,
// then the fully qualified name of the structure isn't presented in `paths`
// yet when its implementation methods are being indexed. Caches such methods
// and their parent id here and indexes them at the end of crate parsing.
- priv orphan_methods: Vec<(ast::NodeId, clean::Item)>,
+ orphan_methods: Vec<(ast::NodeId, clean::Item)>,
}
/// Helper struct to render all source code to HTML pages
/// # Main
/// ### A
/// ## B
- priv entries: Vec<TocEntry>
+ entries: Vec<TocEntry>
}
impl Toc {
#[deriving(Eq)]
pub struct TocEntry {
- priv level: u32,
- priv sec_number: ~str,
- priv name: ~str,
- priv id: ~str,
- priv children: Toc,
+ level: u32,
+ sec_number: ~str,
+ name: ~str,
+ id: ~str,
+ children: Toc,
}
/// Progressive construction of a table of contents.
#[deriving(Eq)]
pub struct TocBuilder {
- priv top_level: Toc,
+ top_level: Toc,
/// The current heirachy of parent headings, the levels are
/// strictly increasing (i.e. chain[0].level < chain[1].level <
/// ...) with each entry being the most recent occurance of a
/// the most recent one).
///
/// We also have `chain[0].level <= top_level.entries[last]`.
- priv chain: Vec<TocEntry>
+ chain: Vec<TocEntry>
}
impl TocBuilder {
/// Manages loading and running of plugins
pub struct PluginManager {
-
priv dylibs: Vec<dl::DynamicLibrary> ,
-
priv callbacks: Vec<PluginCallback> ,
+ dylibs: Vec<dl::DynamicLibrary> ,
+ callbacks: Vec<PluginCallback> ,
/// The directory plugins will be loaded from
- prefix: Path,
+ pub prefix: Path,
}
impl PluginManager {
}
pub struct Collector {
- tests: Vec<testing::TestDescAndFn>,
- priv names: Vec<~str>,
-
priv libs: HashSet<Path>,
- priv cnt: uint,
- priv use_headers: bool,
- priv current_header: Option<~str>,
- priv cratename: ~str,
-
- priv loose_feature_gating: bool
+ pub tests: Vec<testing::TestDescAndFn>,
+ names: Vec<~str>,
+ libs: HashSet<Path>,
+ cnt: uint,
+ use_headers: bool,
+ current_header: Option<~str>,
+ cratename: ~str,
+
+ loose_feature_gating: bool
}
impl Collector {
use doctree::*;
pub struct RustdocVisitor<'a> {
- module: Module,
- attrs: Vec<ast::Attribute> ,
- cx: &'a core::DocContext,
- analysis: Option<&'a core::CrateAnalysis>,
+ pub module: Module,
+ pub attrs: Vec<ast::Attribute>,
+ pub cx: &'a core::DocContext,
+ pub analysis: Option<&'a core::CrateAnalysis>,
}
impl<'a> RustdocVisitor<'a> {
projects / rust.git / commitdiff