RustdocVisitor {
module: Module::new(None),
attrs: hir::HirVec::new(),
- cx: cx,
+ cx,
view_item_stack: stack,
inlining: false,
inside_public_path: true,
let struct_type = struct_type_from_def(&*sd);
Struct {
id: item.id,
- struct_type: struct_type,
- name: name,
+ struct_type,
+ name,
vis: item.vis.clone(),
stab: self.stability(item.id),
depr: self.deprecation(item.id),
let struct_type = struct_type_from_def(&*sd);
Union {
id: item.id,
- struct_type: struct_type,
- name: name,
+ struct_type,
+ name,
vis: item.vis.clone(),
stab: self.stability(item.id),
depr: self.deprecation(item.id),
params: &hir::Generics) -> Enum {
debug!("Visiting enum");
Enum {
- name: name,
+ name,
variants: def.variants.iter().map(|v| Variant {
name: v.node.name,
attrs: v.node.attrs.clone(),
depr: self.deprecation(item.id),
attrs: item.attrs.clone(),
decl: fd.clone(),
- name: name,
+ name,
whence: item.span,
generics: gen.clone(),
unsafety: *unsafety,
- constness: constness,
+ constness,
abi: *abi,
- body: body,
+ body,
}
}
};
om.macros.push(Macro {
- def_id: def_id,
+ def_id,
attrs: def.attrs.clone().into(),
name: def.ident.name,
whence: def.span,
- matchers: matchers,
+ matchers,
stab: self.stability(def.id),
depr: self.deprecation(def.id),
imported_from: Some(imported_from),
if !self.view_item_stack.insert(def_node_id) { return false }
let ret = match tcx.hir.get(def_node_id) {
- hir_map::NodeItem(it) => {
+ hir_map::NodeItem(&hir::Item { node: hir::ItemMod(ref m), .. }) if glob => {
let prev = mem::replace(&mut self.inlining, true);
- if glob {
- match it.node {
- hir::ItemMod(ref m) => {
- for i in &m.item_ids {
- let i = self.cx.tcx.hir.expect_item(i.id);
- self.visit_item(i, None, om);
- }
- }
- hir::ItemEnum(..) => {}
- _ => { panic!("glob not mapped to a module or enum"); }
- }
- } else {
- self.visit_item(it, renamed, om);
+ for i in &m.item_ids {
+ let i = self.cx.tcx.hir.expect_item(i.id);
+ self.visit_item(i, None, om);
}
self.inlining = prev;
true
}
+ hir_map::NodeItem(it) if !glob => {
+ let prev = mem::replace(&mut self.inlining, true);
+ self.visit_item(it, renamed, om);
+ self.inlining = prev;
+ true
+ }
_ => false,
};
self.view_item_stack.remove(&def_node_id);
om.extern_crates.push(ExternCrate {
cnum: cstore.extern_mod_stmt_cnum(item.id)
.unwrap_or(LOCAL_CRATE),
- name: name,
+ name,
path: p.map(|x|x.to_string()),
vis: item.vis.clone(),
attrs: item.attrs.clone(),
}
om.imports.push(Import {
- name: name,
+ name,
id: item.id,
vis: item.vis.clone(),
attrs: item.attrs.clone(),
let t = Typedef {
ty: ty.clone(),
gen: gen.clone(),
- name: name,
+ name,
id: item.id,
attrs: item.attrs.clone(),
whence: item.span,
mutability: mut_.clone(),
expr: exp.clone(),
id: item.id,
- name: name,
+ name,
attrs: item.attrs.clone(),
whence: item.span,
vis: item.vis.clone(),
type_: ty.clone(),
expr: exp.clone(),
id: item.id,
- name: name,
+ name,
attrs: item.attrs.clone(),
whence: item.span,
vis: item.vis.clone(),
.map(|ti| self.cx.tcx.hir.trait_item(ti.id).clone())
.collect();
let t = Trait {
- unsafety: unsafety,
- name: name,
- items: items,
+ unsafety,
+ name,
+ items,
generics: gen.clone(),
bounds: b.iter().cloned().collect(),
id: item.id,
.map(|ii| self.cx.tcx.hir.impl_item(ii.id).clone())
.collect();
let i = Impl {
- unsafety: unsafety,
- polarity: polarity,
- defaultness: defaultness,
+ unsafety,
+ polarity,
+ defaultness,
generics: gen.clone(),
trait_: tr.clone(),
for_: ty.clone(),
- items: items,
+ items,
attrs: item.attrs.clone(),
id: item.id,
whence: item.span,
// See comment above about ItemImpl.
if !self.inlining {
let i = DefaultImpl {
- unsafety: unsafety,
+ unsafety,
trait_: trait_ref.clone(),
id: item.id,
attrs: item.attrs.clone(),
attrs: def.attrs.clone(),
name: def.name,
whence: def.span,
- matchers: matchers,
+ matchers,
stab: self.stability(def.id),
depr: self.deprecation(def.id),
imported_from: None,