frontend 0.4.0

rustc's frontend with no LLVM and no std: parsing through MIR, as a library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use crate::rustc_hir::attrs::CanonicalSymbols;
use crate::rustc_hir::{ForeignItemId, find_attr};
use crate::rustc_middle::query::{LocalCrate, Providers};
use crate::rustc_middle::ty::{Instance, List, TyCtxt};
use crate::rustc_span::def_id::{DefId, LOCAL_CRATE};
use crate::rustc_span::{Symbol, sym};

use crate::rustc_passes::diagnostics::DuplicateCanonicalSymbolInCrate;

fn observe_item<'tcx>(
    tcx: TyCtxt<'tcx>,
    canonical_symbols: &mut CanonicalSymbols,
    fid: ForeignItemId,
) {
    let attrs = tcx.hir_attrs(fid.owner_id.into());
    if find_attr!(attrs, RustcCanonicalSymbol) {
        let did = fid.owner_id.def_id;
        let instance = Instance::new_raw(did.to_def_id(), List::identity_for_item(tcx, did));
        let symbol_name = tcx.symbol_name(instance);
        let symbol_name = Symbol::intern(symbol_name.name);

        // insert into our table
        collect_item(tcx, canonical_symbols, symbol_name, fid.owner_id.to_def_id());
    }
}

fn collect_item(
    tcx: TyCtxt<'_>,
    canonical_symbols: &mut CanonicalSymbols,
    symbol: Symbol,
    item_def_id: DefId,
) {
    if let Some(original_def_id) = canonical_symbols.set(symbol, item_def_id) {
        report_duplicate_item(tcx, symbol, original_def_id, item_def_id);
    }
}

fn report_duplicate_item(
    tcx: TyCtxt<'_>,
    name: Symbol,
    original_def_id: DefId,
    item_def_id: DefId,
) {
    let orig_span = tcx.hir_span_if_local(original_def_id);
    let duplicate_span = tcx.hir_span_if_local(item_def_id);
    tcx.dcx().emit_err(DuplicateCanonicalSymbolInCrate {
        duplicate_span,
        orig_span,
        crate_name: tcx.crate_name(item_def_id.krate),
        orig_crate_name: tcx.crate_name(original_def_id.krate),
        different_crates: (item_def_id.krate != original_def_id.krate),
        name,
    });
}

/// Traverse and collect the canonical symbols in the current crate
fn canonical_symbols(tcx: TyCtxt<'_>, _: LocalCrate) -> CanonicalSymbols {
    // Initialize the collector.
    let mut canonical_symbols = CanonicalSymbols::new();

    // Optimization: can this crate even define canonical items?
    // (But do not mark `rustc_attrs` as used while doing so)
    if tcx.features().enabled_features().contains(&sym::rustc_attrs) {
        // Collect canonical symbols in this crate.
        let crate_items = tcx.hir_crate_items(());
        for id in crate_items.foreign_items() {
            observe_item(tcx, &mut canonical_symbols, id);
        }
    }
    canonical_symbols
}

/// Traverse and collect all the canonical symbols in all crates.
fn all_canonical_symbols(tcx: TyCtxt<'_>, (): ()) -> CanonicalSymbols {
    // Initialize the collector.
    let mut items = CanonicalSymbols::new();

    // Collect all canonical symbols
    for cnum in tcx.crates(()).iter().copied().chain(core::iter::once(LOCAL_CRATE)) {
        for cs in tcx.canonical_symbols(cnum).iter() {
            collect_item(tcx, &mut items, cs.symbol, cs.def_id);
        }
    }

    items
}

pub(crate) fn provide(providers: &mut Providers) {
    providers.canonical_symbols = canonical_symbols;
    providers.all_canonical_symbols = all_canonical_symbols;
}