diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 03fda94a6dfc5..54719e4d6a24e 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2313,22 +2313,49 @@ impl Clean for (&hir::ForeignItem<'_>, Option) { } } -impl Clean for doctree::Macro { +impl Clean for (&hir::MacroDef<'_>, Option) { fn clean(&self, cx: &DocContext<'_>) -> Item { - Item::from_def_id_and_parts( - self.def_id, - Some(self.name.clean(cx)), - MacroItem(Macro { - source: format!( - "macro_rules! {} {{\n{}}}", - self.name, - self.matchers + let (item, renamed) = self; + let name = renamed.unwrap_or(item.ident).name; + let tts = item.ast.body.inner_tokens().trees().collect::>(); + // Extract the spans of all matchers. They represent the "interface" of the macro. + let matchers = tts.chunks(4).map(|arm| arm[0].span()).collect::>(); + let source = if item.ast.macro_rules { + format!( + "macro_rules! {} {{\n{}}}", + name, + matchers + .iter() + .map(|span| { format!(" {} => {{ ... }};\n", span.to_src(cx)) }) + .collect::(), + ) + } else { + let vis = item.vis.clean(cx); + + if matchers.len() <= 1 { + format!( + "{}macro {}{} {{\n ...\n}}", + vis.print_with_space(), + name, + matchers.iter().map(|span| span.to_src(cx)).collect::(), + ) + } else { + format!( + "{}macro {} {{\n{}}}", + vis.print_with_space(), + name, + matchers .iter() - .map(|span| { format!(" {} => {{ ... }};\n", span.to_src(cx)) }) - .collect::() - ), - imported_from: self.imported_from.clean(cx), - }), + .map(|span| { format!(" {} => {{ ... }},\n", span.to_src(cx)) }) + .collect::(), + ) + } + }; + + Item::from_hir_id_and_parts( + item.hir_id, + Some(name), + MacroItem(Macro { source, imported_from: None }), cx, ) } diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 20f747e201415..3961870a1bfad 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -18,7 +18,7 @@ crate struct Module<'hir> { // (item, renamed) crate items: Vec<(&'hir hir::Item<'hir>, Option)>, crate foreigns: Vec<(&'hir hir::ForeignItem<'hir>, Option)>, - crate macros: Vec, + crate macros: Vec<(&'hir hir::MacroDef<'hir>, Option)>, crate is_crate: bool, } @@ -56,15 +56,6 @@ crate struct Variant<'hir> { crate def: &'hir hir::VariantData<'hir>, } -// For Macro we store the DefId instead of the NodeId, since we also create -// these imported macro_rules (which only have a DUMMY_NODE_ID). -crate struct Macro { - crate name: Symbol, - crate def_id: hir::def_id::DefId, - crate matchers: Vec, - crate imported_from: Option, -} - #[derive(Debug)] crate struct Import<'hir> { crate name: Symbol, diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 02152edbbc21c..4028293076df9 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -71,9 +71,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { None, ); // Attach the crate's exported macros to the top-level module: - module - .macros - .extend(krate.exported_macros.iter().map(|def| self.visit_local_macro(def, None))); + module.macros.extend(krate.exported_macros.iter().map(|def| (def, None))); module.is_crate = true; self.cx.renderinfo.get_mut().exact_paths = self.exact_paths; @@ -216,7 +214,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { true } Node::MacroDef(def) if !glob => { - om.macros.push(self.visit_local_macro(def, renamed.map(|i| i.name))); + om.macros.push((def, renamed)); true } _ => false, @@ -339,19 +337,4 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { om.foreigns.push((item, renamed)); } } - - // Convert each `exported_macro` into a doc item. - fn visit_local_macro(&self, def: &'tcx hir::MacroDef<'_>, renamed: Option) -> Macro { - debug!("visit_local_macro: {}", def.ident); - let tts = def.ast.body.inner_tokens().trees().collect::>(); - // Extract the spans of all matchers. They represent the "interface" of the macro. - let matchers = tts.chunks(4).map(|arm| arm[0].span()).collect(); - - Macro { - def_id: self.cx.tcx.hir().local_def_id(def.hir_id).to_def_id(), - name: renamed.unwrap_or(def.ident.name), - matchers, - imported_from: None, - } - } } diff --git a/src/test/rustdoc/decl_macro.rs b/src/test/rustdoc/decl_macro.rs new file mode 100644 index 0000000000000..e48a56f906c95 --- /dev/null +++ b/src/test/rustdoc/decl_macro.rs @@ -0,0 +1,39 @@ +#![feature(decl_macro)] + +// @has decl_macro/macro.my_macro.html //pre 'pub macro my_macro() {' +// @has - //pre '...' +// @has - //pre '}' +pub macro my_macro() { + +} + +// @has decl_macro/macro.my_macro_2.html //pre 'pub macro my_macro_2($($tok:tt)*) {' +// @has - //pre '...' +// @has - //pre '}' +pub macro my_macro_2($($tok:tt)*) { + +} + +// @has decl_macro/macro.my_macro_multi.html //pre 'pub macro my_macro_multi {' +// @has - //pre '(_) => { ... },' +// @has - //pre '($foo:ident . $bar:expr) => { ... },' +// @has - //pre '($($foo:literal),+) => { ... }' +// @has - //pre '}' +pub macro my_macro_multi { + (_) => { + + }, + ($foo:ident . $bar:expr) => { + + }, + ($($foo:literal),+) => { + + } +} + +// @has decl_macro/macro.by_example_single.html //pre 'pub macro by_example_single($foo:expr) {' +// @has - //pre '...' +// @has - //pre '}' +pub macro by_example_single { + ($foo:expr) => {} +} diff --git a/src/test/rustdoc/decl_macro_priv.rs b/src/test/rustdoc/decl_macro_priv.rs new file mode 100644 index 0000000000000..4e1279e34d933 --- /dev/null +++ b/src/test/rustdoc/decl_macro_priv.rs @@ -0,0 +1,14 @@ +// compile-flags: --document-private-items + +#![feature(decl_macro)] + +// @has decl_macro_priv/macro.crate_macro.html //pre 'pub(crate) macro crate_macro() {' +// @has - //pre '...' +// @has - //pre '}' +pub(crate) macro crate_macro() {} + +// @has decl_macro_priv/macro.priv_macro.html //pre 'macro priv_macro() {' +// @!has - //pre 'pub macro priv_macro() {' +// @has - //pre '...' +// @has - //pre '}' +macro priv_macro() {}