1 #![feature(if_let_guard)]
2 #![feature(let_chains)]
3 #![feature(try_blocks)]
4 #![feature(never_type)]
5 #![feature(min_specialization)]
6 #![feature(control_flow_enum)]
7 #![feature(drain_filter)]
8 #![allow(rustc::potential_query_instability)]
9 #![recursion_limit = "256"]
15 extern crate rustc_middle;
31 pub mod expr_use_visitor;
35 mod generator_interior;
38 mod mem_categorization;
47 pub use diverges::Diverges;
48 pub use expectation::Expectation;
50 pub use inherited::{Inherited, InheritedBuilder};
52 use crate::check::check_fn;
53 use crate::coercion::DynamicCoerceMany;
54 use crate::gather_locals::GatherLocalsVisitor;
55 use rustc_data_structures::unord::UnordSet;
56 use rustc_errors::{struct_span_err, DiagnosticId, ErrorGuaranteed, MultiSpan};
58 use rustc_hir::def::{DefKind, Res};
59 use rustc_hir::intravisit::Visitor;
60 use rustc_hir::{HirIdMap, Node};
61 use rustc_hir_analysis::astconv::AstConv;
62 use rustc_hir_analysis::check::check_abi;
63 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
64 use rustc_middle::traits;
65 use rustc_middle::ty::query::Providers;
66 use rustc_middle::ty::{self, Ty, TyCtxt};
67 use rustc_session::config;
68 use rustc_session::Session;
69 use rustc_span::def_id::{DefId, LocalDefId};
73 macro_rules! type_error_struct {
74 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
75 let mut err = rustc_errors::struct_span_err!($session, $span, $code, $($message)*);
77 if $typ.references_error() {
78 err.downgrade_to_delayed_bug();
85 /// The type of a local binding, including the revealed type for anon types.
86 #[derive(Copy, Clone, Debug)]
87 pub struct LocalTy<'tcx> {
89 revealed_ty: Ty<'tcx>,
92 #[derive(Copy, Clone)]
93 pub struct UnsafetyState {
95 pub unsafety: hir::Unsafety,
100 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
101 UnsafetyState { def, unsafety, from_fn: true }
104 pub fn recurse(self, blk: &hir::Block<'_>) -> UnsafetyState {
105 use hir::BlockCheckMode;
106 match self.unsafety {
107 // If this unsafe, then if the outer function was already marked as
108 // unsafe we shouldn't attribute the unsafe'ness to the block. This
109 // way the block can be warned about instead of ignoring this
110 // extraneous block (functions are never warned about).
111 hir::Unsafety::Unsafe if self.from_fn => self,
114 let (unsafety, def) = match blk.rules {
115 BlockCheckMode::UnsafeBlock(..) => (hir::Unsafety::Unsafe, blk.hir_id),
116 BlockCheckMode::DefaultBlock => (unsafety, self.def),
118 UnsafetyState { def, unsafety, from_fn: false }
124 /// If this `DefId` is a "primary tables entry", returns
125 /// `Some((body_id, body_ty, fn_sig))`. Otherwise, returns `None`.
127 /// If this function returns `Some`, then `typeck_results(def_id)` will
128 /// succeed; if it returns `None`, then `typeck_results(def_id)` may or
129 /// may not succeed. In some cases where this function returns `None`
130 /// (notably closures), `typeck_results(def_id)` would wind up
131 /// redirecting to the owning function.
135 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnSig<'_>>)> {
136 match tcx.hir().get(id) {
137 Node::Item(item) => match item.kind {
138 hir::ItemKind::Const(ty, body) | hir::ItemKind::Static(ty, _, body) => {
139 Some((body, Some(ty), None))
141 hir::ItemKind::Fn(ref sig, .., body) => Some((body, None, Some(sig))),
144 Node::TraitItem(item) => match item.kind {
145 hir::TraitItemKind::Const(ty, Some(body)) => Some((body, Some(ty), None)),
146 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
147 Some((body, None, Some(sig)))
151 Node::ImplItem(item) => match item.kind {
152 hir::ImplItemKind::Const(ty, body) => Some((body, Some(ty), None)),
153 hir::ImplItemKind::Fn(ref sig, body) => Some((body, None, Some(sig))),
156 Node::AnonConst(constant) => Some((constant.body, None, None)),
161 fn has_typeck_results(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
162 // Closures' typeck results come from their outermost function,
163 // as they are part of the same "inference environment".
164 let typeck_root_def_id = tcx.typeck_root_def_id(def_id);
165 if typeck_root_def_id != def_id {
166 return tcx.has_typeck_results(typeck_root_def_id);
169 if let Some(def_id) = def_id.as_local() {
170 let id = tcx.hir().local_def_id_to_hir_id(def_id);
171 primary_body_of(tcx, id).is_some()
177 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDefId> {
178 &*tcx.typeck(def_id).used_trait_imports
181 fn typeck_item_bodies(tcx: TyCtxt<'_>, (): ()) {
182 tcx.hir().par_body_owners(|body_owner_def_id| tcx.ensure().typeck(body_owner_def_id));
185 fn typeck_const_arg<'tcx>(
187 (did, param_did): (LocalDefId, DefId),
188 ) -> &ty::TypeckResults<'tcx> {
189 let fallback = move || tcx.type_of(param_did);
190 typeck_with_fallback(tcx, did, fallback)
193 fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
194 if let Some(param_did) = tcx.opt_const_param_of(def_id) {
195 tcx.typeck_const_arg((def_id, param_did))
197 let fallback = move || tcx.type_of(def_id.to_def_id());
198 typeck_with_fallback(tcx, def_id, fallback)
202 /// Used only to get `TypeckResults` for type inference during error recovery.
203 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
204 fn diagnostic_only_typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
205 let fallback = move || {
206 let span = tcx.hir().span(tcx.hir().local_def_id_to_hir_id(def_id));
207 tcx.ty_error_with_message(span, "diagnostic only typeck table used")
209 typeck_with_fallback(tcx, def_id, fallback)
212 #[instrument(level = "debug", skip(tcx, fallback), ret)]
213 fn typeck_with_fallback<'tcx>(
216 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
217 ) -> &'tcx ty::TypeckResults<'tcx> {
218 // Closures' typeck results come from their outermost function,
219 // as they are part of the same "inference environment".
220 let typeck_root_def_id = tcx.typeck_root_def_id(def_id.to_def_id()).expect_local();
221 if typeck_root_def_id != def_id {
222 return tcx.typeck(typeck_root_def_id);
225 let id = tcx.hir().local_def_id_to_hir_id(def_id);
226 let span = tcx.hir().span(id);
228 // Figure out what primary body this item has.
229 let (body_id, body_ty, fn_sig) = primary_body_of(tcx, id).unwrap_or_else(|| {
230 span_bug!(span, "can't type-check body of {:?}", def_id);
232 let body = tcx.hir().body(body_id);
234 let typeck_results = Inherited::build(tcx, def_id).enter(|inh| {
235 let param_env = tcx.param_env(def_id);
236 let mut fcx = if let Some(hir::FnSig { header, decl, .. }) = fn_sig {
237 let fn_sig = if rustc_hir_analysis::collect::get_infer_ret_ty(&decl.output).is_some() {
238 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
239 <dyn AstConv<'_>>::ty_of_fn(&fcx, id, header.unsafety, header.abi, decl, None, None)
244 check_abi(tcx, id, span, fn_sig.abi());
246 // Compute the function signature from point of view of inside the fn.
247 let fn_sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), fn_sig);
248 let fn_sig = inh.normalize_associated_types_in(
254 check_fn(&inh, param_env, fn_sig, decl, def_id, body, None).0
256 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
257 let expected_type = body_ty
258 .and_then(|ty| match ty.kind {
259 hir::TyKind::Infer => Some(<dyn AstConv<'_>>::ast_ty_to_ty(&fcx, ty)),
262 .unwrap_or_else(|| match tcx.hir().get(id) {
263 Node::AnonConst(_) => match tcx.hir().get(tcx.hir().get_parent_node(id)) {
264 Node::Expr(&hir::Expr {
265 kind: hir::ExprKind::ConstBlock(ref anon_const),
267 }) if anon_const.hir_id == id => fcx.next_ty_var(TypeVariableOrigin {
268 kind: TypeVariableOriginKind::TypeInference,
272 kind: hir::TyKind::Typeof(ref anon_const), ..
273 }) if anon_const.hir_id == id => fcx.next_ty_var(TypeVariableOrigin {
274 kind: TypeVariableOriginKind::TypeInference,
277 Node::Expr(&hir::Expr { kind: hir::ExprKind::InlineAsm(asm), .. })
278 | Node::Item(&hir::Item { kind: hir::ItemKind::GlobalAsm(asm), .. }) => {
282 .filter_map(|(op, _op_sp)| match op {
283 hir::InlineAsmOperand::Const { anon_const }
284 if anon_const.hir_id == id =>
286 // Inline assembly constants must be integers.
287 Some(fcx.next_int_var())
289 hir::InlineAsmOperand::SymFn { anon_const }
290 if anon_const.hir_id == id =>
292 Some(fcx.next_ty_var(TypeVariableOrigin {
293 kind: TypeVariableOriginKind::MiscVariable,
300 operand_ty.unwrap_or_else(fallback)
307 let expected_type = fcx.normalize_associated_types_in(body.value.span, expected_type);
308 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
310 // Gather locals in statics (because of block expressions).
311 GatherLocalsVisitor::new(&fcx).visit_body(body);
313 fcx.check_expr_coercable_to_type(&body.value, expected_type, None);
315 fcx.write_ty(id, expected_type);
320 fcx.type_inference_fallback();
322 // Even though coercion casts provide type hints, we check casts after fallback for
323 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
325 fcx.select_obligations_where_possible(|_| {});
327 // Closure and generator analysis may run after fallback
328 // because they don't constrain other type variables.
329 // Closure analysis only runs on closures. Therefore they only need to fulfill non-const predicates (as of now)
330 let prev_constness = fcx.param_env.constness();
331 fcx.param_env = fcx.param_env.without_const();
332 fcx.closure_analyze(body);
333 fcx.param_env = fcx.param_env.with_constness(prev_constness);
334 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
335 // Before the generator analysis, temporary scopes shall be marked to provide more
336 // precise information on types to be captured.
337 fcx.resolve_rvalue_scopes(def_id.to_def_id());
338 fcx.resolve_generator_interiors(def_id.to_def_id());
340 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
341 let ty = fcx.normalize_ty(span, ty);
342 fcx.require_type_is_sized(ty, span, code);
345 fcx.select_all_obligations_or_error();
347 if let None = fcx.infcx.tainted_by_errors() {
348 fcx.check_transmutes();
353 fcx.infcx.skip_region_resolution();
355 fcx.resolve_type_vars_in_body(body)
358 // Consistency check our TypeckResults instance can hold all ItemLocalIds
359 // it will need to hold.
360 assert_eq!(typeck_results.hir_owner, id.owner);
365 /// When `check_fn` is invoked on a generator (i.e., a body that
366 /// includes yield), it returns back some information about the yield
368 struct GeneratorTypes<'tcx> {
369 /// Type of generator argument / values returned by `yield`.
372 /// Type of value that is yielded.
375 /// Types that are captured (see `GeneratorInterior` for more).
378 /// Indicates if the generator is movable or static (immovable).
379 movability: hir::Movability,
382 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
389 fn maybe_mut_place(m: hir::Mutability) -> Self {
391 hir::Mutability::Mut => Needs::MutPlace,
392 hir::Mutability::Not => Needs::None,
397 #[derive(Debug, Copy, Clone)]
403 pub struct BreakableCtxt<'tcx> {
406 // this is `null` for loops where break with a value is illegal,
407 // such as `while`, `for`, and `while let`
408 coerce: Option<DynamicCoerceMany<'tcx>>,
411 pub struct EnclosingBreakables<'tcx> {
412 stack: Vec<BreakableCtxt<'tcx>>,
413 by_id: HirIdMap<usize>,
416 impl<'tcx> EnclosingBreakables<'tcx> {
417 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
418 self.opt_find_breakable(target_id).unwrap_or_else(|| {
419 bug!("could not find enclosing breakable with id {}", target_id);
423 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
424 match self.by_id.get(&target_id) {
425 Some(ix) => Some(&mut self.stack[*ix]),
431 fn report_unexpected_variant_res(
434 qpath: &hir::QPath<'_>,
438 ) -> ErrorGuaranteed {
439 let res_descr = match res {
440 Res::Def(DefKind::Variant, _) => "struct variant",
443 let path_str = rustc_hir_pretty::qpath_to_string(qpath);
444 let mut err = tcx.sess.struct_span_err_with_code(
446 format!("expected {expected}, found {res_descr} `{path_str}`"),
447 DiagnosticId::Error(err_code.into()),
450 Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == "E0164" => {
451 let patterns_url = "https://doc.rust-lang.org/book/ch18-00-patterns.html";
452 err.span_label(span, "`fn` calls are not allowed in patterns");
453 err.help(format!("for more information, visit {patterns_url}"))
455 _ => err.span_label(span, format!("not a {expected}")),
460 /// Controls whether the arguments are tupled. This is used for the call
463 /// Tupling means that all call-side arguments are packed into a tuple and
464 /// passed as a single parameter. For example, if tupling is enabled, this
467 /// fn f(x: (isize, isize)) {}
469 /// Can be called as:
470 /// ```ignore UNSOLVED (can this be done in user code?)
471 /// # fn f(x: (isize, isize)) {}
476 /// # fn f(x: (isize, isize)) {}
479 #[derive(Copy, Clone, Eq, PartialEq)]
480 enum TupleArgumentsFlag {
485 fn fatally_break_rust(sess: &Session) {
486 let handler = sess.diagnostic();
487 handler.span_bug_no_panic(
489 "It looks like you're trying to break rust; would you like some ICE?",
491 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
492 handler.note_without_error(
493 "we would appreciate a joke overview: \
494 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
496 handler.note_without_error(&format!(
497 "rustc {} running on {}",
498 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
499 config::host_triple(),
503 fn has_expected_num_generic_args<'tcx>(
505 trait_did: Option<DefId>,
508 trait_did.map_or(true, |trait_did| {
509 let generics = tcx.generics_of(trait_did);
510 generics.count() == expected + if generics.has_self { 1 } else { 0 }
514 pub fn provide(providers: &mut Providers) {
515 method::provide(providers);
516 *providers = Providers {
520 diagnostic_only_typeck,