rustc_passes/
check_export.rs

1use std::iter;
2use std::ops::ControlFlow;
3
4use rustc_abi::ExternAbi;
5use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
6use rustc_hir as hir;
7use rustc_hir::def::DefKind;
8use rustc_hir::def_id::{DefId, LocalDefId};
9use rustc_hir::find_attr;
10use rustc_hir::intravisit::{self, Visitor};
11use rustc_middle::hir::nested_filter;
12use rustc_middle::middle::privacy::{EffectiveVisibility, Level};
13use rustc_middle::query::{LocalCrate, Providers};
14use rustc_middle::ty::{
15    self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor, Unnormalized, Visibility,
16};
17use rustc_session::config::CrateType;
18use rustc_span::Span;
19
20use crate::diagnostics::UnexportableItem;
21
22struct ExportableItemCollector<'tcx> {
23    tcx: TyCtxt<'tcx>,
24    exportable_items: FxIndexSet<DefId>,
25    in_exportable_mod: bool,
26    seen_exportable_in_mod: bool,
27}
28
29impl<'tcx> ExportableItemCollector<'tcx> {
30    fn new(tcx: TyCtxt<'tcx>) -> ExportableItemCollector<'tcx> {
31        ExportableItemCollector {
32            tcx,
33            exportable_items: Default::default(),
34            in_exportable_mod: false,
35            seen_exportable_in_mod: false,
36        }
37    }
38
39    fn report_wrong_site(&self, def_id: LocalDefId) {
40        let def_descr = self.tcx.def_descr(def_id.to_def_id());
41        self.tcx.dcx().emit_err(UnexportableItem::Item {
42            descr: &::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}", def_descr))
    })format!("{}", def_descr),
43            span: self.tcx.def_span(def_id),
44        });
45    }
46
47    fn item_is_exportable(&self, def_id: LocalDefId) -> bool {
48        let has_attr = {
        {
            'done:
                {
                for i in
                    ::rustc_hir::attrs::HasAttrs::get_attrs(def_id, &self.tcx) {
                    #[allow(unused_imports)]
                    use rustc_hir::attrs::AttributeKind::*;
                    let i: &rustc_hir::Attribute = i;
                    match i {
                        rustc_hir::Attribute::Parsed(ExportStable) => {
                            break 'done Some(());
                        }
                        rustc_hir::Attribute::Unparsed(..) =>
                            {}
                            #[deny(unreachable_patterns)]
                            _ => {}
                    }
                }
                None
            }
        }
    }.is_some()find_attr!(self.tcx, def_id, ExportStable);
49        if !self.in_exportable_mod && !has_attr {
50            return false;
51        }
52
53        let visibilities = self.tcx.effective_visibilities(());
54        let is_pub = visibilities.is_directly_public(def_id);
55
56        if has_attr && !is_pub {
57            let vis = visibilities.effective_vis(def_id).cloned().unwrap_or_else(|| {
58                EffectiveVisibility::from_vis(Visibility::Restricted(
59                    self.tcx.parent_module_from_def_id(def_id).to_local_def_id(),
60                ))
61            });
62            let vis = vis.at_level(Level::Direct);
63            let span = self.tcx.def_span(def_id);
64
65            self.tcx.dcx().emit_err(UnexportableItem::PrivItem {
66                vis_note: span,
67                vis_descr: &vis.to_string(def_id, self.tcx),
68                span,
69            });
70            return false;
71        }
72
73        is_pub && (has_attr || self.in_exportable_mod)
74    }
75
76    fn add_exportable(&mut self, def_id: LocalDefId) {
77        self.seen_exportable_in_mod = true;
78        self.exportable_items.insert(def_id.to_def_id());
79    }
80
81    fn walk_item_with_mod(&mut self, item: &'tcx hir::Item<'tcx>) {
82        let def_id = item.hir_id().owner.def_id;
83        let old_exportable_mod = self.in_exportable_mod;
84        if {
        {
            'done:
                {
                for i in
                    ::rustc_hir::attrs::HasAttrs::get_attrs(def_id, &self.tcx) {
                    #[allow(unused_imports)]
                    use rustc_hir::attrs::AttributeKind::*;
                    let i: &rustc_hir::Attribute = i;
                    match i {
                        rustc_hir::Attribute::Parsed(ExportStable) => {
                            break 'done Some(());
                        }
                        rustc_hir::Attribute::Unparsed(..) =>
                            {}
                            #[deny(unreachable_patterns)]
                            _ => {}
                    }
                }
                None
            }
        }
    }.is_some()find_attr!(self.tcx, def_id, ExportStable) {
85            self.in_exportable_mod = true;
86        }
87        let old_seen_exportable_in_mod = std::mem::replace(&mut self.seen_exportable_in_mod, false);
88
89        intravisit::walk_item(self, item);
90
91        if self.seen_exportable_in_mod || self.in_exportable_mod {
92            self.exportable_items.insert(def_id.to_def_id());
93        }
94
95        self.seen_exportable_in_mod = old_seen_exportable_in_mod;
96        self.in_exportable_mod = old_exportable_mod;
97    }
98}
99
100impl<'tcx> Visitor<'tcx> for ExportableItemCollector<'tcx> {
101    type NestedFilter = nested_filter::All;
102
103    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
104        self.tcx
105    }
106
107    fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
108        let def_id = item.hir_id().owner.def_id;
109        // Applying #[extern] attribute to modules is simply equivalent to
110        // applying the attribute to every public item within it.
111        match item.kind {
112            hir::ItemKind::Mod(..) => {
113                self.walk_item_with_mod(item);
114                return;
115            }
116            hir::ItemKind::Impl(impl_) if impl_.of_trait.is_none() => {
117                self.walk_item_with_mod(item);
118                return;
119            }
120            _ => {}
121        }
122
123        if !self.item_is_exportable(def_id) {
124            return;
125        }
126
127        match item.kind {
128            hir::ItemKind::Fn { .. }
129            | hir::ItemKind::Struct(..)
130            | hir::ItemKind::Enum(..)
131            | hir::ItemKind::Union(..)
132            | hir::ItemKind::TyAlias(..) => {
133                self.add_exportable(def_id);
134            }
135            hir::ItemKind::Use(path, _) => {
136                for res in path.res.present_items() {
137                    // Only local items are exportable.
138                    if let Some(res_id) = res.opt_def_id()
139                        && let Some(res_id) = res_id.as_local()
140                    {
141                        self.add_exportable(res_id);
142                    }
143                }
144            }
145            // handled above
146            hir::ItemKind::Mod(..) => ::core::panicking::panic("internal error: entered unreachable code")unreachable!(),
147            hir::ItemKind::Impl(impl_) if impl_.of_trait.is_none() => {
148                ::core::panicking::panic("internal error: entered unreachable code");unreachable!();
149            }
150            _ => {
151                self.tcx.dcx().delayed_bug("Target is checked by attribute parser");
152            }
153        }
154    }
155
156    fn visit_impl_item(&mut self, item: &'tcx hir::ImplItem<'tcx>) {
157        let def_id = item.hir_id().owner.def_id;
158        if !self.item_is_exportable(def_id) {
159            return;
160        }
161        match item.kind {
162            hir::ImplItemKind::Fn(..) | hir::ImplItemKind::Type(..) => {
163                self.add_exportable(def_id);
164            }
165            _ => self.report_wrong_site(def_id),
166        }
167    }
168
169    fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) {
170        let def_id = item.hir_id().owner.def_id;
171        if !self.item_is_exportable(def_id) {
172            self.report_wrong_site(def_id);
173        }
174    }
175
176    fn visit_trait_item(&mut self, item: &'tcx hir::TraitItem<'tcx>) {
177        let def_id = item.hir_id().owner.def_id;
178        if !self.item_is_exportable(def_id) {
179            self.report_wrong_site(def_id);
180        }
181    }
182}
183
184struct ExportableItemsChecker<'tcx, 'a> {
185    tcx: TyCtxt<'tcx>,
186    exportable_items: &'a FxIndexSet<DefId>,
187    item_id: DefId,
188}
189
190impl<'tcx, 'a> ExportableItemsChecker<'tcx, 'a> {
191    fn check(&mut self) {
192        match self.tcx.def_kind(self.item_id) {
193            DefKind::Fn | DefKind::AssocFn => self.check_fn(),
194            DefKind::Enum | DefKind::Struct | DefKind::Union => self.check_ty(),
195            _ => {}
196        }
197    }
198
199    fn check_fn(&mut self) {
200        let def_id = self.item_id.expect_local();
201        let span = self.tcx.def_span(def_id);
202
203        if self.tcx.generics_of(def_id).requires_monomorphization(self.tcx) {
204            self.tcx.dcx().emit_err(UnexportableItem::GenericFn(span));
205            return;
206        }
207
208        let sig = self.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
209        if !#[allow(non_exhaustive_omitted_patterns)] match sig.abi() {
    ExternAbi::C { .. } => true,
    _ => false,
}matches!(sig.abi(), ExternAbi::C { .. }) {
210            self.tcx.dcx().emit_err(UnexportableItem::FnAbi(span));
211            return;
212        }
213
214        let sig = self
215            .tcx
216            .try_normalize_erasing_regions(
217                ty::TypingEnv::non_body_analysis(self.tcx, def_id),
218                Unnormalized::new_wip(sig),
219            )
220            .unwrap_or(sig);
221
222        let hir_id = self.tcx.local_def_id_to_hir_id(def_id);
223        let decl = self.tcx.hir_fn_decl_by_hir_id(hir_id).unwrap();
224
225        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
226            self.check_nested_types_are_exportable(*input_ty, input_hir.span);
227        }
228
229        if let hir::FnRetTy::Return(ret_hir) = decl.output {
230            self.check_nested_types_are_exportable(sig.output(), ret_hir.span);
231        }
232    }
233
234    fn check_ty(&mut self) {
235        let ty = self.tcx.type_of(self.item_id).skip_binder();
236        if let ty::Adt(adt_def, _) = ty.kind() {
237            if !adt_def.repr().inhibit_struct_field_reordering() {
238                self.tcx
239                    .dcx()
240                    .emit_err(UnexportableItem::TypeRepr(self.tcx.def_span(self.item_id)));
241            }
242
243            // FIXME: support `#[export(unsafe_stable_abi = "hash")]` syntax
244            for variant in adt_def.variants() {
245                for field in &variant.fields {
246                    if !field.vis.is_public() {
247                        self.tcx.dcx().emit_err(UnexportableItem::AdtWithPrivFields {
248                            span: self.tcx.def_span(self.item_id),
249                            vis_note: self.tcx.def_span(field.did),
250                            field_name: field.name.as_str(),
251                        });
252                    }
253                }
254            }
255        }
256    }
257
258    fn check_nested_types_are_exportable(&mut self, ty: Ty<'tcx>, ty_span: Span) {
259        let res = ty.visit_with(self);
260        if let Some(err_cause) = res.break_value() {
261            self.tcx.dcx().emit_err(UnexportableItem::TypeInInterface {
262                span: self.tcx.def_span(self.item_id),
263                desc: self.tcx.def_descr(self.item_id),
264                ty: &::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}", err_cause))
    })format!("{}", err_cause),
265                ty_span,
266            });
267        }
268    }
269}
270
271impl<'tcx, 'a> TypeVisitor<TyCtxt<'tcx>> for ExportableItemsChecker<'tcx, 'a> {
272    type Result = ControlFlow<Ty<'tcx>>;
273
274    fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
275        match ty.kind() {
276            ty::Adt(adt_def, _) => {
277                let did = adt_def.did();
278                let exportable = if did.is_local() {
279                    self.exportable_items.contains(&did)
280                } else {
281                    self.tcx.is_exportable(did)
282                };
283                if !exportable {
284                    return ControlFlow::Break(ty);
285                }
286                for variant in adt_def.variants() {
287                    for field in &variant.fields {
288                        let field_ty =
289                            self.tcx.type_of(field.did).instantiate_identity().skip_norm_wip();
290                        field_ty.visit_with(self)?;
291                    }
292                }
293
294                return ty.super_visit_with(self);
295            }
296
297            ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Bool | ty::Char | ty::Error(_) => {}
298
299            ty::Array(_, _)
300            | ty::Ref(_, _, _)
301            | ty::Param(_)
302            | ty::Closure(_, _)
303            | ty::Dynamic(_, _)
304            | ty::Coroutine(_, _)
305            | ty::Foreign(_)
306            | ty::Str
307            | ty::Tuple(_)
308            | ty::Pat(..)
309            | ty::Slice(_)
310            | ty::RawPtr(_, _)
311            | ty::FnDef(_, _)
312            | ty::FnPtr(_, _)
313            | ty::CoroutineClosure(_, _)
314            | ty::CoroutineWitness(_, _)
315            | ty::Never
316            | ty::UnsafeBinder(_)
317            | ty::Alias(_, ty::AliasTy { kind: ty::AliasTyKind::Opaque { .. }, .. }) => {
318                return ControlFlow::Break(ty);
319            }
320
321            ty::Alias(..) | ty::Infer(_) | ty::Placeholder(_) | ty::Bound(..) => ::core::panicking::panic("internal error: entered unreachable code")unreachable!(),
322        }
323        ControlFlow::Continue(())
324    }
325}
326
327/// Exportable items:
328///
329/// 1. Structs/enums/unions with a stable representation (e.g. repr(i32) or repr(C)).
330/// 2. Primitive types.
331/// 3. Non-generic functions with a stable ABI (e.g. extern "C") for which every user
332///    defined type used in the signature is also marked as `#[export]`.
333fn exportable_items_provider_local<'tcx>(tcx: TyCtxt<'tcx>, _: LocalCrate) -> &'tcx [DefId] {
334    if !tcx.crate_types().contains(&CrateType::Sdylib) && !tcx.is_sdylib_interface_build() {
335        return &[];
336    }
337
338    let mut visitor = ExportableItemCollector::new(tcx);
339    tcx.hir_walk_toplevel_module(&mut visitor);
340    let exportable_items = visitor.exportable_items;
341    for item_id in exportable_items.iter() {
342        let mut validator =
343            ExportableItemsChecker { tcx, exportable_items: &exportable_items, item_id: *item_id };
344        validator.check();
345    }
346
347    tcx.arena.alloc_from_iter(exportable_items.into_iter())
348}
349
350struct ImplsOrderVisitor<'tcx> {
351    tcx: TyCtxt<'tcx>,
352    order: FxIndexMap<DefId, usize>,
353}
354
355impl<'tcx> ImplsOrderVisitor<'tcx> {
356    fn new(tcx: TyCtxt<'tcx>) -> ImplsOrderVisitor<'tcx> {
357        ImplsOrderVisitor { tcx, order: Default::default() }
358    }
359}
360
361impl<'tcx> Visitor<'tcx> for ImplsOrderVisitor<'tcx> {
362    type NestedFilter = nested_filter::All;
363
364    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
365        self.tcx
366    }
367
368    fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
369        if let hir::ItemKind::Impl(impl_) = item.kind
370            && impl_.of_trait.is_none()
371            && self.tcx.is_exportable(item.owner_id.def_id.to_def_id())
372        {
373            self.order.insert(item.owner_id.def_id.to_def_id(), self.order.len());
374        }
375        intravisit::walk_item(self, item);
376    }
377}
378
379/// During symbol mangling rustc uses a special index to distinguish between two impls of
380/// the same type in the same module(See `DisambiguatedDefPathData`). For exportable items
381/// we cannot use the current approach because it is dependent on the compiler's
382/// implementation.
383///
384/// In order to make disambiguation independent of the compiler version we can assign an
385/// id to each impl according to the relative order of elements in the source code.
386fn stable_order_of_exportable_impls<'tcx>(
387    tcx: TyCtxt<'tcx>,
388    _: LocalCrate,
389) -> &'tcx FxIndexMap<DefId, usize> {
390    if !tcx.crate_types().contains(&CrateType::Sdylib) && !tcx.is_sdylib_interface_build() {
391        return tcx.arena.alloc(FxIndexMap::<DefId, usize>::default());
392    }
393
394    let mut vis = ImplsOrderVisitor::new(tcx);
395    tcx.hir_walk_toplevel_module(&mut vis);
396    tcx.arena.alloc(vis.order)
397}
398
399pub(crate) fn provide(providers: &mut Providers) {
400    *providers = Providers {
401        exportable_items: exportable_items_provider_local,
402        stable_order_of_exportable_impls,
403        ..*providers
404    };
405}
rustc_passes/check_export.rs

rustc_passes/
check_export.rs
