frontend 0.4.1

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// `#![no_std]`: these arrive with the standard prelude and name no path, so a `std::`
// search cannot see them - and a `#[derive]` can use them without the name appearing
// in this file at all, which is why they are not trimmed by inspection.
use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;

use crate::rustc_hir::def::DefKind;
use crate::rustc_hir::def_id::LocalDefId;
use crate::rustc_middle::ty::{self, CrateClausesMap, GenericArgKind, TyCtxt, Upcast};
use crate::rustc_span::Span;

pub(crate) mod dump;
mod explicit;
mod implicit_infer;
mod utils;

pub(super) fn inferred_outlives_of(
    tcx: TyCtxt<'_>,
    item_def_id: LocalDefId,
) -> &[(ty::Clause<'_>, Span)] {
    match tcx.def_kind(item_def_id) {
        DefKind::Struct | DefKind::Enum | DefKind::Union => {
            let crate_map = tcx.inferred_outlives_crate(());
            crate_map.clauses.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
        }
        DefKind::TyAlias if tcx.type_alias_is_checked(item_def_id) => {
            let crate_map = tcx.inferred_outlives_crate(());
            crate_map.clauses.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
        }
        DefKind::AnonConst if tcx.features().generic_const_exprs() => {
            let id = tcx.local_def_id_to_hir_id(item_def_id);
            if tcx.hir_opt_const_param_default_param_def_id(id).is_some() {
                // In `generics_of` we set the generics' parent to be our parent's parent which means that
                // we lose out on the clauses of our actual parent if we dont return those clauses here.
                // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
                //
                // struct Foo<'a, 'b, const N: usize = { ... }>(&'a &'b ());
                //        ^^^                          ^^^^^^^ the def id we are calling
                //        ^^^                                  inferred_outlives_of on
                //        parent item we dont have set as the
                //        parent of generics returned by `generics_of`
                //
                // In the above code we want the anon const to have clauses in its param env for `'b: 'a`
                let item_def_id = tcx.hir_get_parent_item(id);
                // In the above code example we would be calling `inferred_outlives_of(Foo)` here
                tcx.inferred_outlives_of(item_def_id)
            } else {
                &[]
            }
        }
        _ => &[],
    }
}

pub(super) fn inferred_outlives_crate(tcx: TyCtxt<'_>, (): ()) -> CrateClausesMap<'_> {
    // Compute a map from each ADT (struct/enum/union) and lazy type alias to
    // the **explicit** outlives clauses (`T: 'a`, `'a: 'b`) that the user wrote.
    // Typically there won't be many of these, except in older code where
    // they were mandatory. Nonetheless, we have to ensure that every such
    // clause is satisfied, so they form a kind of base set of requirements
    // for the type.

    // Compute the inferred clauses
    let global_inferred_outlives = implicit_infer::infer_clauses(tcx);

    // Convert the inferred clauses into the "collected" form the
    // global data structure expects.
    //
    // FIXME -- consider correcting impedance mismatch in some way,
    // probably by updating the global data structure.
    let clauses = global_inferred_outlives
        .iter()
        .map(|(&def_id, set)| {
            let clauses =
                &*tcx.arena.alloc_from_iter(set.as_ref().skip_binder().iter().filter_map(
                    |(ty::OutlivesClause(arg1, region2), &span)| {
                        match arg1.kind() {
                            GenericArgKind::Type(ty1) => Some((
                                ty::ClauseKind::TypeOutlives(ty::OutlivesClause(ty1, *region2))
                                    .upcast(tcx),
                                span,
                            )),
                            GenericArgKind::Lifetime(region1) => Some((
                                ty::ClauseKind::RegionOutlives(ty::OutlivesClause(
                                    region1, *region2,
                                ))
                                .upcast(tcx),
                                span,
                            )),
                            GenericArgKind::Const(_) => {
                                // Generic consts don't impose any constraints.
                                None
                            }
                        }
                    },
                ));
            (def_id, clauses)
        })
        .collect();

    ty::CrateClausesMap { clauses }
}