rustc_mir_build/thir/cx/
mod.rs

1//! This module contains the functionality to convert from the wacky tcx data
2//! structures into the THIR. The `builder` is generally ignorant of the tcx,
3//! etc., and instead goes through the `Cx` for most of its work.
4
5use rustc_data_structures::steal::Steal;
6use rustc_errors::ErrorGuaranteed;
7use rustc_hir as hir;
8use rustc_hir::HirId;
9use rustc_hir::def::DefKind;
10use rustc_hir::def_id::{DefId, LocalDefId};
11use rustc_hir::lang_items::LangItem;
12use rustc_middle::bug;
13use rustc_middle::middle::region;
14use rustc_middle::thir::*;
15use rustc_middle::ty::{self, RvalueScopes, TyCtxt};
16use tracing::instrument;
17
18use crate::thir::pattern::pat_from_hir;
19
20/// Query implementation for [`TyCtxt::thir_body`].
21pub(crate) fn thir_body(
22    tcx: TyCtxt<'_>,
23    owner_def: LocalDefId,
24) -> Result<(&Steal<Thir<'_>>, ExprId), ErrorGuaranteed> {
25    let body = tcx.hir_body_owned_by(owner_def);
26    let mut cx = ThirBuildCx::new(tcx, owner_def);
27    if let Some(reported) = cx.typeck_results.tainted_by_errors {
28        return Err(reported);
29    }
30
31    // Lower the params before the body's expression so errors from params are shown first.
32    let owner_id = tcx.local_def_id_to_hir_id(owner_def);
33    if let Some(fn_decl) = tcx.hir_fn_decl_by_hir_id(owner_id) {
34        let closure_env_param = cx.closure_env_param(owner_def, owner_id);
35        let explicit_params = cx.explicit_params(owner_id, fn_decl, &body);
36        cx.thir.params = closure_env_param.into_iter().chain(explicit_params).collect();
37
38        // The resume argument may be missing, in that case we need to provide it here.
39        // It will always be `()` in this case.
40        if tcx.is_coroutine(owner_def.to_def_id()) && body.params.is_empty() {
41            cx.thir.params.push(Param {
42                ty: tcx.types.unit,
43                pat: None,
44                ty_span: None,
45                self_kind: None,
46                hir_id: None,
47            });
48        }
49    }
50
51    let expr = cx.mirror_expr(body.value);
52    Ok((tcx.alloc_steal_thir(cx.thir), expr))
53}
54
55/// Context for lowering HIR to THIR for a single function body (or other kind of body).
56struct ThirBuildCx<'tcx> {
57    tcx: TyCtxt<'tcx>,
58    /// The THIR data that this context is building.
59    thir: Thir<'tcx>,
60
61    typing_env: ty::TypingEnv<'tcx>,
62
63    region_scope_tree: &'tcx region::ScopeTree,
64    typeck_results: &'tcx ty::TypeckResults<'tcx>,
65    rvalue_scopes: &'tcx RvalueScopes,
66
67    /// False to indicate that adjustments should not be applied. Only used for `custom_mir`
68    apply_adjustments: bool,
69
70    /// The `DefId` of the owner of this body.
71    body_owner: DefId,
72}
73
74impl<'tcx> ThirBuildCx<'tcx> {
75    fn new(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
76        let typeck_results = tcx.typeck(def);
77        let hir_id = tcx.local_def_id_to_hir_id(def);
78
79        let body_type = match tcx.hir_body_owner_kind(def) {
80            rustc_hir::BodyOwnerKind::Fn | rustc_hir::BodyOwnerKind::Closure => {
81                // fetch the fully liberated fn signature (that is, all bound
82                // types/lifetimes replaced)
83                BodyTy::Fn(typeck_results.liberated_fn_sigs()[hir_id])
84            }
85            rustc_hir::BodyOwnerKind::Const { .. } | rustc_hir::BodyOwnerKind::Static(_) => {
86                // Get the revealed type of this const. This is *not* the adjusted
87                // type of its body, which may be a subtype of this type. For
88                // example:
89                //
90                // fn foo(_: &()) {}
91                // static X: fn(&'static ()) = foo;
92                //
93                // The adjusted type of the body of X is `for<'a> fn(&'a ())` which
94                // is not the same as the type of X. We need the type of the return
95                // place to be the type of the constant because NLL typeck will
96                // equate them.
97                BodyTy::Const(typeck_results.node_type(hir_id))
98            }
99            rustc_hir::BodyOwnerKind::GlobalAsm => {
100                BodyTy::GlobalAsm(typeck_results.node_type(hir_id))
101            }
102        };
103
104        Self {
105            tcx,
106            thir: Thir::new(body_type),
107            // FIXME(#132279): We're in a body, we should use a typing
108            // mode which reveals the opaque types defined by that body.
109            typing_env: ty::TypingEnv::non_body_analysis(tcx, def),
110            region_scope_tree: tcx.region_scope_tree(def),
111            typeck_results,
112            rvalue_scopes: &typeck_results.rvalue_scopes,
113            body_owner: def.to_def_id(),
114            apply_adjustments: tcx
115                .hir_attrs(hir_id)
116                .iter()
117                .all(|attr| !attr.has_name(rustc_span::sym::custom_mir)),
118        }
119    }
120
121    #[instrument(level = "debug", skip(self))]
122    fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
123        pat_from_hir(self.tcx, self.typing_env, self.typeck_results, p)
124    }
125
126    fn closure_env_param(&self, owner_def: LocalDefId, expr_id: HirId) -> Option<Param<'tcx>> {
127        if self.tcx.def_kind(owner_def) != DefKind::Closure {
128            return None;
129        }
130
131        let closure_ty = self.typeck_results.node_type(expr_id);
132        Some(match *closure_ty.kind() {
133            ty::Coroutine(..) => {
134                Param { ty: closure_ty, pat: None, ty_span: None, self_kind: None, hir_id: None }
135            }
136            ty::Closure(_, args) => {
137                let closure_env_ty = self.tcx.closure_env_ty(
138                    closure_ty,
139                    args.as_closure().kind(),
140                    self.tcx.lifetimes.re_erased,
141                );
142                Param {
143                    ty: closure_env_ty,
144                    pat: None,
145                    ty_span: None,
146                    self_kind: None,
147                    hir_id: None,
148                }
149            }
150            ty::CoroutineClosure(_, args) => {
151                let closure_env_ty = self.tcx.closure_env_ty(
152                    closure_ty,
153                    args.as_coroutine_closure().kind(),
154                    self.tcx.lifetimes.re_erased,
155                );
156                Param {
157                    ty: closure_env_ty,
158                    pat: None,
159                    ty_span: None,
160                    self_kind: None,
161                    hir_id: None,
162                }
163            }
164            _ => bug!("unexpected closure type: {closure_ty}"),
165        })
166    }
167
168    fn explicit_params(
169        &mut self,
170        owner_id: HirId,
171        fn_decl: &'tcx hir::FnDecl<'tcx>,
172        body: &'tcx hir::Body<'tcx>,
173    ) -> impl Iterator<Item = Param<'tcx>> {
174        let fn_sig = self.typeck_results.liberated_fn_sigs()[owner_id];
175
176        body.params.iter().enumerate().map(move |(index, param)| {
177            let ty_span = fn_decl
178                .inputs
179                .get(index)
180                // Make sure that inferred closure args have no type span
181                .and_then(|ty| if param.pat.span != ty.span { Some(ty.span) } else { None });
182
183            let self_kind = if index == 0 && fn_decl.implicit_self.has_implicit_self() {
184                Some(fn_decl.implicit_self)
185            } else {
186                None
187            };
188
189            // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
190            // (as it's created inside the body itself, not passed in from outside).
191            let ty = if fn_decl.c_variadic && index == fn_decl.inputs.len() {
192                let va_list_did = self.tcx.require_lang_item(LangItem::VaList, Some(param.span));
193
194                self.tcx
195                    .type_of(va_list_did)
196                    .instantiate(self.tcx, &[self.tcx.lifetimes.re_erased.into()])
197            } else {
198                fn_sig.inputs()[index]
199            };
200
201            let pat = self.pattern_from_hir(param.pat);
202            Param { pat: Some(pat), ty, ty_span, self_kind, hir_id: Some(param.hir_id) }
203        })
204    }
205
206    fn user_args_applied_to_ty_of_hir_id(
207        &self,
208        hir_id: HirId,
209    ) -> Option<ty::CanonicalUserType<'tcx>> {
210        crate::thir::util::user_args_applied_to_ty_of_hir_id(self.tcx, self.typeck_results, hir_id)
211    }
212}
213
214mod block;
215mod expr;
rustc_mir_build/thir/cx/mod.rs

rustc_mir_build/thir/cx/
mod.rs
