2
2
3
3
use std:: mem;
4
4
5
+ use rustc_data_structures:: fx:: FxHashMap ;
5
6
use rustc_hir:: def_id:: { CRATE_DEF_ID , LocalDefId } ;
6
7
use rustc_middle:: ty:: TyCtxt ;
7
8
use rustc_span:: symbol:: sym;
8
9
use tracing:: debug;
9
10
10
- use crate :: clean;
11
11
use crate :: clean:: utils:: inherits_doc_hidden;
12
- use crate :: clean:: { Item , ItemIdSet } ;
12
+ use crate :: clean:: { self , Item , ItemId , ItemIdSet } ;
13
13
use crate :: core:: DocContext ;
14
14
use crate :: fold:: { DocFolder , strip_item} ;
15
15
use crate :: passes:: { ImplStripper , Pass } ;
@@ -25,6 +25,28 @@ pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clea
25
25
let mut retained = ItemIdSet :: default ( ) ;
26
26
let is_json_output = cx. is_json_output ( ) ;
27
27
28
+ let all_items = collect_items ( & krate) ;
29
+
30
+ // Collect hidden items
31
+ let hidden_items: Vec < _ > =
32
+ all_items. iter ( ) . filter ( |item| item. is_doc_hidden ( ) ) . cloned ( ) . collect ( ) ;
33
+
34
+ // Map import items to their hidden source items
35
+ let source_items: FxHashMap < _ , _ > = all_items
36
+ . iter ( )
37
+ . filter_map ( |item| {
38
+ if let clean:: ItemKind :: ImportItem ( import) = & item. kind {
39
+ let source_item = hidden_items
40
+ . iter ( )
41
+ . find ( |i| i. item_id . as_def_id ( ) == import. source . did )
42
+ . cloned ( ) ;
43
+ Some ( ( item. item_id , source_item) )
44
+ } else {
45
+ None
46
+ }
47
+ } )
48
+ . collect ( ) ;
49
+
28
50
// strip all #[doc(hidden)] items
29
51
let krate = {
30
52
let mut stripper = Stripper {
@@ -33,6 +55,7 @@ pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clea
33
55
tcx : cx. tcx ,
34
56
is_in_hidden_item : false ,
35
57
last_reexport : None ,
58
+ source_items,
36
59
} ;
37
60
stripper. fold_crate ( krate)
38
61
} ;
@@ -49,12 +72,30 @@ pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clea
49
72
stripper. fold_crate ( krate)
50
73
}
51
74
75
+ fn collect_items ( krate : & clean:: Crate ) -> Vec < Item > {
76
+ fn collect_items_module ( module : & clean:: Module ) -> Vec < Item > {
77
+ let mut items = Vec :: new ( ) ;
78
+ for item in & module. items {
79
+ items. push ( item. clone ( ) ) ;
80
+ }
81
+ items
82
+ }
83
+
84
+ let mut items = Vec :: new ( ) ;
85
+ if let clean:: ItemKind :: ModuleItem ( module) = & krate. module . kind {
86
+ items. extend ( collect_items_module ( module) ) ;
87
+ }
88
+ items
89
+ }
90
+
52
91
struct Stripper < ' a , ' tcx > {
53
92
retained : & ' a mut ItemIdSet ,
54
93
update_retained : bool ,
55
94
tcx : TyCtxt < ' tcx > ,
56
95
is_in_hidden_item : bool ,
57
96
last_reexport : Option < LocalDefId > ,
97
+ /// store the source items of a import item
98
+ source_items : FxHashMap < ItemId , Option < Item > > ,
58
99
}
59
100
60
101
impl Stripper < ' _ , ' _ > {
@@ -89,6 +130,25 @@ impl Stripper<'_, '_> {
89
130
impl DocFolder for Stripper < ' _ , ' _ > {
90
131
fn fold_item ( & mut self , i : Item ) -> Option < Item > {
91
132
let has_doc_hidden = i. is_doc_hidden ( ) ;
133
+ debug ! (
134
+ "kkkkkkkkkkkkkk {:?}, item: {:?}, has_doc_hidden: {}, is_in_hidden_item: {}\n " ,
135
+ i. name, i, has_doc_hidden, self . is_in_hidden_item
136
+ ) ;
137
+
138
+ // if self.hidden_items.iter().any(|item| item.item_id == i.item_id) {
139
+ // return None;
140
+ // }
141
+
142
+ if let clean:: ImportItem ( clean:: Import { .. } ) = & i. kind {
143
+ if let Some ( source_item) = self . source_items . get ( & i. item_id ) {
144
+ if let Some ( source_item) = source_item {
145
+ if source_item. is_doc_hidden ( ) {
146
+ return None ;
147
+ }
148
+ }
149
+ }
150
+ }
151
+
92
152
let is_impl_or_exported_macro = match i. kind {
93
153
clean:: ImplItem ( ..) => true ,
94
154
// If the macro has the `#[macro_export]` attribute, it means it's accessible at the
0 commit comments