5 Within the check phase of type check, we check each item one at a time
6 (bodies of function expressions are checked as part of the containing
7 function). Inference is used to supply types wherever they are unknown.
9 By far the most complex case is checking the body of a function. This
10 can be broken down into several distinct phases:
12 - gather: creates type variables to represent the type of each local
13 variable and pattern binding.
15 - main: the main pass does the lion's share of the work: it
16 determines the types of all expressions, resolves
17 methods, checks for most invalid conditions, and so forth. In
18 some cases, where a type is unknown, it may create a type or region
19 variable and use that as the type of an expression.
21 In the process of checking, various constraints will be placed on
22 these type variables through the subtyping relationships requested
23 through the `demand` module. The `infer` module is in charge
24 of resolving those constraints.
26 - regionck: after main is complete, the regionck pass goes over all
27 types looking for regions and making sure that they did not escape
28 into places they are not in scope. This may also influence the
29 final assignments of the various region variables if there is some
32 - writeback: writes the final types within a function body, replacing
33 type variables with their final inferred types. These final types
34 are written into the `tcx.node_types` table, which should *never* contain
35 any reference to a type variable.
39 While type checking a function, the intermediate types for the
40 expressions, blocks, and so forth contained within the function are
41 stored in `fcx.node_types` and `fcx.node_substs`. These types
42 may contain unresolved type variables. After type checking is
43 complete, the functions in the writeback module are used to take the
44 types from this table, resolve them, and then write them into their
45 permanent home in the type context `tcx`.
47 This means that during inferencing you should use `fcx.write_ty()`
48 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
49 nodes within the function.
51 The types of top-level items, which never contain unbound type
52 variables, are stored directly into the `tcx` typeck_results.
54 N.B., a type variable is not the same thing as a type parameter. A
55 type variable is rather an "instance" of a type parameter: that is,
56 given a generic function `fn foo<T>(t: T)`: while checking the
57 function `foo`, the type `ty_param(0)` refers to the type `T`, which
58 is treated in abstract. When `foo()` is called, however, `T` will be
59 substituted for a fresh type variable `N`. This variable will
60 eventually be resolved to some concrete type (which might itself be
80 mod generator_interior;
93 check_abi, check_fn, check_impl_item_well_formed, check_item_well_formed, check_mod_item_types,
94 check_trait_item_well_formed,
96 pub use check::{check_item_type, check_wf_new};
97 pub use diverges::Diverges;
98 pub use expectation::Expectation;
99 pub use fn_ctxt::FnCtxt;
100 pub use inherited::{Inherited, InheritedBuilder};
102 use crate::astconv::AstConv;
103 use crate::check::gather_locals::GatherLocalsVisitor;
104 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
105 use rustc_errors::{pluralize, struct_span_err, Applicability};
106 use rustc_hir as hir;
107 use rustc_hir::def::Res;
108 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
109 use rustc_hir::intravisit::Visitor;
110 use rustc_hir::itemlikevisit::ItemLikeVisitor;
111 use rustc_hir::{HirIdMap, Node};
112 use rustc_index::bit_set::BitSet;
113 use rustc_index::vec::Idx;
114 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
115 use rustc_middle::ty::query::Providers;
116 use rustc_middle::ty::subst::GenericArgKind;
117 use rustc_middle::ty::subst::{InternalSubsts, Subst, SubstsRef};
118 use rustc_middle::ty::WithConstness;
119 use rustc_middle::ty::{self, RegionKind, Ty, TyCtxt, UserType};
120 use rustc_session::config;
121 use rustc_session::parse::feature_err;
122 use rustc_session::Session;
123 use rustc_span::source_map::DUMMY_SP;
124 use rustc_span::symbol::{kw, Ident};
125 use rustc_span::{self, BytePos, MultiSpan, Span};
126 use rustc_target::abi::VariantIdx;
127 use rustc_target::spec::abi::Abi;
128 use rustc_trait_selection::traits;
129 use rustc_trait_selection::traits::error_reporting::recursive_type_with_infinite_size_error;
130 use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;
132 use std::cell::{Ref, RefCell, RefMut};
134 use crate::require_c_abi_if_c_variadic;
135 use crate::util::common::indenter;
137 use self::coercion::DynamicCoerceMany;
138 pub use self::Expectation::*;
141 macro_rules! type_error_struct {
142 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
143 if $typ.references_error() {
144 $session.diagnostic().struct_dummy()
146 rustc_errors::struct_span_err!($session, $span, $code, $($message)*)
151 /// The type of a local binding, including the revealed type for anon types.
152 #[derive(Copy, Clone, Debug)]
153 pub struct LocalTy<'tcx> {
155 revealed_ty: Ty<'tcx>,
158 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
165 fn maybe_mut_place(m: hir::Mutability) -> Self {
167 hir::Mutability::Mut => Needs::MutPlace,
168 hir::Mutability::Not => Needs::None,
173 #[derive(Copy, Clone)]
174 pub struct UnsafetyState {
176 pub unsafety: hir::Unsafety,
177 pub unsafe_push_count: u32,
182 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
183 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
186 pub fn recurse(&mut self, blk: &hir::Block<'_>) -> UnsafetyState {
187 use hir::BlockCheckMode;
188 match self.unsafety {
189 // If this unsafe, then if the outer function was already marked as
190 // unsafe we shouldn't attribute the unsafe'ness to the block. This
191 // way the block can be warned about instead of ignoring this
192 // extraneous block (functions are never warned about).
193 hir::Unsafety::Unsafe if self.from_fn => *self,
196 let (unsafety, def, count) = match blk.rules {
197 BlockCheckMode::PushUnsafeBlock(..) => {
198 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
200 BlockCheckMode::PopUnsafeBlock(..) => {
201 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
203 BlockCheckMode::UnsafeBlock(..) => {
204 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
206 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
208 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
214 #[derive(Debug, Copy, Clone)]
220 pub struct BreakableCtxt<'tcx> {
223 // this is `null` for loops where break with a value is illegal,
224 // such as `while`, `for`, and `while let`
225 coerce: Option<DynamicCoerceMany<'tcx>>,
228 pub struct EnclosingBreakables<'tcx> {
229 stack: Vec<BreakableCtxt<'tcx>>,
230 by_id: HirIdMap<usize>,
233 impl<'tcx> EnclosingBreakables<'tcx> {
234 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
235 self.opt_find_breakable(target_id).unwrap_or_else(|| {
236 bug!("could not find enclosing breakable with id {}", target_id);
240 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
241 match self.by_id.get(&target_id) {
242 Some(ix) => Some(&mut self.stack[*ix]),
248 pub fn provide(providers: &mut Providers) {
249 method::provide(providers);
250 *providers = Providers {
254 diagnostic_only_typeck,
258 check_item_well_formed,
259 check_trait_item_well_formed,
260 check_impl_item_well_formed,
261 check_mod_item_types,
266 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
267 tcx.calculate_dtor(def_id, dropck::check_drop_impl)
270 /// If this `DefId` is a "primary tables entry", returns
271 /// `Some((body_id, header, decl))` with information about
272 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
275 /// If this function returns `Some`, then `typeck_results(def_id)` will
276 /// succeed; if it returns `None`, then `typeck_results(def_id)` may or
277 /// may not succeed. In some cases where this function returns `None`
278 /// (notably closures), `typeck_results(def_id)` would wind up
279 /// redirecting to the owning function.
283 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
284 match tcx.hir().get(id) {
285 Node::Item(item) => match item.kind {
286 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
287 Some((body, Some(ty), None, None))
289 hir::ItemKind::Fn(ref sig, .., body) => {
290 Some((body, None, Some(&sig.header), Some(&sig.decl)))
294 Node::TraitItem(item) => match item.kind {
295 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
296 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
297 Some((body, None, Some(&sig.header), Some(&sig.decl)))
301 Node::ImplItem(item) => match item.kind {
302 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
303 hir::ImplItemKind::Fn(ref sig, body) => {
304 Some((body, None, Some(&sig.header), Some(&sig.decl)))
308 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
313 fn has_typeck_results(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
314 // Closures' typeck results come from their outermost function,
315 // as they are part of the same "inference environment".
316 let outer_def_id = tcx.closure_base_def_id(def_id);
317 if outer_def_id != def_id {
318 return tcx.has_typeck_results(outer_def_id);
321 if let Some(def_id) = def_id.as_local() {
322 let id = tcx.hir().local_def_id_to_hir_id(def_id);
323 primary_body_of(tcx, id).is_some()
329 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &FxHashSet<LocalDefId> {
330 &*tcx.typeck(def_id).used_trait_imports
333 /// Inspects the substs of opaque types, replacing any inference variables
334 /// with proper generic parameter from the identity substs.
336 /// This is run after we normalize the function signature, to fix any inference
337 /// variables introduced by the projection of associated types. This ensures that
338 /// any opaque types used in the signature continue to refer to generic parameters,
339 /// allowing them to be considered for defining uses in the function body
341 /// For example, consider this code.
346 /// fn use_it(self) -> Self::MyItem
348 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
349 /// type MyItem = impl Iterator<Item = I>;
350 /// fn use_it(self) -> Self::MyItem {
356 /// When we normalize the signature of `use_it` from the impl block,
357 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
358 /// However, this projection result may contain inference variables, due
359 /// to the way that projection works. We didn't have any inference variables
360 /// in the signature to begin with - leaving them in will cause us to incorrectly
361 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
362 /// variables back to the actual generic parameters, we will correctly see that
363 /// we have a defining use of `MyItem`
364 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
366 T: TypeFoldable<'tcx>,
368 struct FixupFolder<'tcx> {
372 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
373 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
377 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
379 ty::Opaque(def_id, substs) => {
380 debug!("fixup_opaque_types: found type {:?}", ty);
381 // Here, we replace any inference variables that occur within
382 // the substs of an opaque type. By definition, any type occurring
383 // in the substs has a corresponding generic parameter, which is what
384 // we replace it with.
385 // This replacement is only run on the function signature, so any
386 // inference variables that we come across must be the rust of projection
387 // (there's no other way for a user to get inference variables into
388 // a function signature).
389 if ty.needs_infer() {
390 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
391 let old_param = substs[param.index as usize];
392 match old_param.unpack() {
393 GenericArgKind::Type(old_ty) => {
394 if let ty::Infer(_) = old_ty.kind() {
395 // Replace inference type with a generic parameter
396 self.tcx.mk_param_from_def(param)
398 old_param.fold_with(self)
401 GenericArgKind::Const(old_const) => {
402 if let ty::ConstKind::Infer(_) = old_const.val {
403 // This should never happen - we currently do not support
404 // 'const projections', e.g.:
405 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
406 // which should be the only way for us to end up with a const inference
407 // variable after projection. If Rust ever gains support for this kind
408 // of projection, this should *probably* be changed to
409 // `self.tcx.mk_param_from_def(param)`
411 "Found infer const: `{:?}` in opaque type: {:?}",
416 old_param.fold_with(self)
419 GenericArgKind::Lifetime(old_region) => {
420 if let RegionKind::ReVar(_) = old_region {
421 self.tcx.mk_param_from_def(param)
423 old_param.fold_with(self)
428 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
429 debug!("fixup_opaque_types: new type: {:?}", new_ty);
435 _ => ty.super_fold_with(self),
440 debug!("fixup_opaque_types({:?})", val);
441 val.fold_with(&mut FixupFolder { tcx })
444 fn typeck_const_arg<'tcx>(
446 (did, param_did): (LocalDefId, DefId),
447 ) -> &ty::TypeckResults<'tcx> {
448 let fallback = move || tcx.type_of(param_did);
449 typeck_with_fallback(tcx, did, fallback)
452 fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
453 if let Some(param_did) = tcx.opt_const_param_of(def_id) {
454 tcx.typeck_const_arg((def_id, param_did))
456 let fallback = move || tcx.type_of(def_id.to_def_id());
457 typeck_with_fallback(tcx, def_id, fallback)
461 /// Used only to get `TypeckResults` for type inference during error recovery.
462 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
463 fn diagnostic_only_typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
464 let fallback = move || {
465 let span = tcx.hir().span(tcx.hir().local_def_id_to_hir_id(def_id));
466 tcx.ty_error_with_message(span, "diagnostic only typeck table used")
468 typeck_with_fallback(tcx, def_id, fallback)
471 fn typeck_with_fallback<'tcx>(
474 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
475 ) -> &'tcx ty::TypeckResults<'tcx> {
476 // Closures' typeck results come from their outermost function,
477 // as they are part of the same "inference environment".
478 let outer_def_id = tcx.closure_base_def_id(def_id.to_def_id()).expect_local();
479 if outer_def_id != def_id {
480 return tcx.typeck(outer_def_id);
483 let id = tcx.hir().local_def_id_to_hir_id(def_id);
484 let span = tcx.hir().span(id);
486 // Figure out what primary body this item has.
487 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
488 span_bug!(span, "can't type-check body of {:?}", def_id);
490 let body = tcx.hir().body(body_id);
492 let typeck_results = Inherited::build(tcx, def_id).enter(|inh| {
493 let param_env = tcx.param_env(def_id);
494 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
495 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
496 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
502 &hir::Generics::empty(),
509 check_abi(tcx, span, fn_sig.abi());
511 // Compute the fty from point of view of inside the fn.
512 let fn_sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), &fn_sig);
513 let fn_sig = inh.normalize_associated_types_in(
520 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
522 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
525 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
526 let expected_type = body_ty
527 .and_then(|ty| match ty.kind {
528 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
531 .unwrap_or_else(fallback);
532 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
533 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
535 let revealed_ty = if tcx.features().impl_trait_in_bindings {
536 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
541 // Gather locals in statics (because of block expressions).
542 GatherLocalsVisitor::new(&fcx, id).visit_body(body);
544 fcx.check_expr_coercable_to_type(&body.value, revealed_ty, None);
546 fcx.write_ty(id, revealed_ty);
551 // All type checking constraints were added, try to fallback unsolved variables.
552 fcx.select_obligations_where_possible(false, |_| {});
553 let mut fallback_has_occurred = false;
555 // We do fallback in two passes, to try to generate
556 // better error messages.
557 // The first time, we do *not* replace opaque types.
558 for ty in &fcx.unsolved_variables() {
559 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
561 // We now see if we can make progress. This might
562 // cause us to unify inference variables for opaque types,
563 // since we may have unified some other type variables
564 // during the first phase of fallback.
565 // This means that we only replace inference variables with their underlying
566 // opaque types as a last resort.
568 // In code like this:
571 // type MyType = impl Copy;
572 // fn produce() -> MyType { true }
573 // fn bad_produce() -> MyType { panic!() }
576 // we want to unify the opaque inference variable in `bad_produce`
577 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
578 // This will produce a nice error message about conflicting concrete
579 // types for `MyType`.
581 // If we had tried to fallback the opaque inference variable to `MyType`,
582 // we will generate a confusing type-check error that does not explicitly
583 // refer to opaque types.
584 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
586 // We now run fallback again, but this time we allow it to replace
587 // unconstrained opaque type variables, in addition to performing
588 // other kinds of fallback.
589 for ty in &fcx.unsolved_variables() {
590 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
593 // See if we can make any more progress.
594 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
596 // Even though coercion casts provide type hints, we check casts after fallback for
597 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
600 // Closure and generator analysis may run after fallback
601 // because they don't constrain other type variables.
602 fcx.closure_analyze(body);
603 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
604 fcx.resolve_generator_interiors(def_id.to_def_id());
606 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
607 let ty = fcx.normalize_ty(span, ty);
608 fcx.require_type_is_sized(ty, span, code);
611 fcx.select_all_obligations_or_error();
613 if fn_decl.is_some() {
614 fcx.regionck_fn(id, body);
616 fcx.regionck_expr(body);
619 fcx.resolve_type_vars_in_body(body)
622 // Consistency check our TypeckResults instance can hold all ItemLocalIds
623 // it will need to hold.
624 assert_eq!(typeck_results.hir_owner, id.owner);
629 /// When `check_fn` is invoked on a generator (i.e., a body that
630 /// includes yield), it returns back some information about the yield
632 struct GeneratorTypes<'tcx> {
633 /// Type of generator argument / values returned by `yield`.
636 /// Type of value that is yielded.
639 /// Types that are captured (see `GeneratorInterior` for more).
642 /// Indicates if the generator is movable or static (immovable).
643 movability: hir::Movability,
646 /// Given a `DefId` for an opaque type in return position, find its parent item's return
648 fn get_owner_return_paths(
651 ) -> Option<(hir::HirId, ReturnsVisitor<'tcx>)> {
652 let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
653 let id = tcx.hir().get_parent_item(hir_id);
657 .and_then(|(hir_id, node)| node.body_id().map(|b| (hir_id, b)))
658 .map(|(hir_id, body_id)| {
659 let body = tcx.hir().body(body_id);
660 let mut visitor = ReturnsVisitor::default();
661 visitor.visit_body(body);
666 /// Emit an error for recursive opaque types in a `let` binding.
667 fn binding_opaque_type_cycle_error(
671 partially_expanded_type: Ty<'tcx>,
673 let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type");
674 err.span_label(span, "cannot resolve opaque type");
675 // Find the owner that declared this `impl Trait` type.
676 let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
677 let mut prev_hir_id = hir_id;
678 let mut hir_id = tcx.hir().get_parent_node(hir_id);
679 while let Some(node) = tcx.hir().find(hir_id) {
681 hir::Node::Local(hir::Local {
685 source: hir::LocalSource::Normal,
688 err.span_label(pat.span, "this binding might not have a concrete type");
689 err.span_suggestion_verbose(
690 ty.span.shrink_to_hi(),
691 "set the binding to a value for a concrete type to be resolved",
692 " = /* value */".to_string(),
693 Applicability::HasPlaceholders,
696 hir::Node::Local(hir::Local {
698 source: hir::LocalSource::Normal,
701 let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
703 tcx.typeck(tcx.hir().local_def_id(tcx.hir().get_parent_item(hir_id)));
704 if let Some(ty) = typeck_results.node_type_opt(expr.hir_id) {
708 "this is of type `{}`, which doesn't constrain \
709 `{}` enough to arrive to a concrete type",
710 ty, partially_expanded_type
717 if prev_hir_id == hir_id {
720 prev_hir_id = hir_id;
721 hir_id = tcx.hir().get_parent_node(hir_id);
726 // Forbid defining intrinsics in Rust code,
727 // as they must always be defined by the compiler.
728 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
729 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
730 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
734 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: LocalDefId, span: Span) {
735 // Only restricted on wasm32 target for now
736 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
740 // If `#[link_section]` is missing, then nothing to verify
741 let attrs = tcx.codegen_fn_attrs(id);
742 if attrs.link_section.is_none() {
746 // For the wasm32 target statics with `#[link_section]` are placed into custom
747 // sections of the final output file, but this isn't link custom sections of
748 // other executable formats. Namely we can only embed a list of bytes,
749 // nothing with pointers to anything else or relocations. If any relocation
750 // show up, reject them here.
751 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
752 // the consumer's responsibility to ensure all bytes that have been read
753 // have defined values.
754 match tcx.eval_static_initializer(id.to_def_id()) {
756 if alloc.relocations().len() != 0 {
757 let msg = "statics with a custom `#[link_section]` must be a \
758 simple list of bytes on the wasm target with no \
759 extra levels of indirection such as references";
760 tcx.sess.span_err(span, msg);
767 fn report_forbidden_specialization(
769 impl_item: &hir::ImplItem<'_>,
772 let mut err = struct_span_err!(
776 "`{}` specializes an item from a parent `impl`, but \
777 that item is not marked `default`",
780 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
782 match tcx.span_of_impl(parent_impl) {
784 err.span_label(span, "parent `impl` is here");
786 "to specialize, `{}` in the parent `impl` must be marked `default`",
791 err.note(&format!("parent implementation is in crate `{}`", cname));
798 fn missing_items_err(
801 missing_items: &[ty::AssocItem],
802 full_impl_span: Span,
804 let missing_items_msg = missing_items
806 .map(|trait_item| trait_item.ident.to_string())
810 let mut err = struct_span_err!(
814 "not all trait items implemented, missing: `{}`",
817 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
819 // `Span` before impl block closing brace.
820 let hi = full_impl_span.hi() - BytePos(1);
821 // Point at the place right before the closing brace of the relevant `impl` to suggest
822 // adding the associated item at the end of its body.
823 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
824 // Obtain the level of indentation ending in `sugg_sp`.
825 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
826 // Make the whitespace that will make the suggestion have the right indentation.
827 let padding: String = (0..indentation).map(|_| " ").collect();
829 for trait_item in missing_items {
830 let snippet = suggestion_signature(&trait_item, tcx);
831 let code = format!("{}{}\n{}", padding, snippet, padding);
832 let msg = format!("implement the missing item: `{}`", snippet);
833 let appl = Applicability::HasPlaceholders;
834 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
835 err.span_label(span, format!("`{}` from trait", trait_item.ident));
836 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
838 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
844 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
845 fn bounds_from_generic_predicates<'tcx>(
847 predicates: ty::GenericPredicates<'tcx>,
848 ) -> (String, String) {
849 let mut types: FxHashMap<Ty<'tcx>, Vec<DefId>> = FxHashMap::default();
850 let mut projections = vec![];
851 for (predicate, _) in predicates.predicates {
852 debug!("predicate {:?}", predicate);
853 match predicate.skip_binders() {
854 ty::PredicateAtom::Trait(trait_predicate, _) => {
855 let entry = types.entry(trait_predicate.self_ty()).or_default();
856 let def_id = trait_predicate.def_id();
857 if Some(def_id) != tcx.lang_items().sized_trait() {
858 // Type params are `Sized` by default, do not add that restriction to the list
859 // if it is a positive requirement.
860 entry.push(trait_predicate.def_id());
863 ty::PredicateAtom::Projection(projection_pred) => {
864 projections.push(ty::Binder::bind(projection_pred));
869 let generics = if types.is_empty() {
876 .filter_map(|t| match t.kind() {
877 ty::Param(_) => Some(t.to_string()),
878 // Avoid suggesting the following:
879 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
886 let mut where_clauses = vec![];
887 for (ty, bounds) in types {
888 for bound in &bounds {
889 where_clauses.push(format!("{}: {}", ty, tcx.def_path_str(*bound)));
892 for projection in &projections {
893 let p = projection.skip_binder();
894 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
895 // insert the associated types where they correspond, but for now let's be "lazy" and
896 // propose this instead of the following valid resugaring:
897 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
898 where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.item_def_id), p.ty));
900 let where_clauses = if where_clauses.is_empty() {
903 format!(" where {}", where_clauses.join(", "))
905 (generics, where_clauses)
908 /// Return placeholder code for the given function.
909 fn fn_sig_suggestion<'tcx>(
911 sig: ty::FnSig<'tcx>,
913 predicates: ty::GenericPredicates<'tcx>,
914 assoc: &ty::AssocItem,
921 Some(match ty.kind() {
922 ty::Param(_) if assoc.fn_has_self_parameter && i == 0 => "self".to_string(),
923 ty::Ref(reg, ref_ty, mutability) if i == 0 => {
924 let reg = match &format!("{}", reg)[..] {
925 "'_" | "" => String::new(),
926 reg => format!("{} ", reg),
928 if assoc.fn_has_self_parameter {
929 match ref_ty.kind() {
930 ty::Param(param) if param.name == kw::SelfUpper => {
931 format!("&{}{}self", reg, mutability.prefix_str())
934 _ => format!("self: {}", ty),
941 if assoc.fn_has_self_parameter && i == 0 {
942 format!("self: {}", ty)
949 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
950 .filter_map(|arg| arg)
951 .collect::<Vec<String>>()
953 let output = sig.output();
954 let output = if !output.is_unit() { format!(" -> {}", output) } else { String::new() };
956 let unsafety = sig.unsafety.prefix_str();
957 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
959 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
960 // not be present in the `fn` definition, not will we account for renamed
961 // lifetimes between the `impl` and the `trait`, but this should be good enough to
962 // fill in a significant portion of the missing code, and other subsequent
963 // suggestions can help the user fix the code.
965 "{}fn {}{}({}){}{} {{ todo!() }}",
966 unsafety, ident, generics, args, output, where_clauses
970 /// Return placeholder code for the given associated item.
971 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
972 /// structured suggestion.
973 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
975 ty::AssocKind::Fn => {
976 // We skip the binder here because the binder would deanonymize all
977 // late-bound regions, and we don't want method signatures to show up
978 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
979 // regions just fine, showing `fn(&MyType)`.
982 tcx.fn_sig(assoc.def_id).skip_binder(),
984 tcx.predicates_of(assoc.def_id),
988 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
989 ty::AssocKind::Const => {
990 let ty = tcx.type_of(assoc.def_id);
991 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
992 format!("const {}: {} = {};", assoc.ident, ty, val)
997 /// Emit an error when encountering more or less than one variant in a transparent enum.
998 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
999 let variant_spans: Vec<_> = adt
1002 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
1004 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
1005 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1006 err.span_label(sp, &msg);
1007 if let [start @ .., end] = &*variant_spans {
1008 for variant_span in start {
1009 err.span_label(*variant_span, "");
1011 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1016 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1018 fn bad_non_zero_sized_fields<'tcx>(
1020 adt: &'tcx ty::AdtDef,
1022 field_spans: impl Iterator<Item = Span>,
1025 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1026 let mut err = struct_span_err!(
1030 "{}transparent {} {}",
1031 if adt.is_enum() { "the variant of a " } else { "" },
1035 err.span_label(sp, &msg);
1036 for sp in field_spans {
1037 err.span_label(sp, "this field is non-zero-sized");
1042 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
1047 "expected unit struct, unit variant or constant, found {}{}",
1049 tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`", s)),
1054 /// Controls whether the arguments are tupled. This is used for the call
1057 /// Tupling means that all call-side arguments are packed into a tuple and
1058 /// passed as a single parameter. For example, if tupling is enabled, this
1061 /// fn f(x: (isize, isize))
1063 /// Can be called as:
1070 #[derive(Clone, Eq, PartialEq)]
1071 enum TupleArgumentsFlag {
1076 /// Controls how we perform fallback for unconstrained
1079 /// Do not fallback type variables to opaque types.
1081 /// Perform all possible kinds of fallback, including
1082 /// turning type variables to opaque types.
1086 /// A wrapper for `InferCtxt`'s `in_progress_typeck_results` field.
1087 #[derive(Copy, Clone)]
1088 struct MaybeInProgressTables<'a, 'tcx> {
1089 maybe_typeck_results: Option<&'a RefCell<ty::TypeckResults<'tcx>>>,
1092 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
1093 fn borrow(self) -> Ref<'a, ty::TypeckResults<'tcx>> {
1094 match self.maybe_typeck_results {
1095 Some(typeck_results) => typeck_results.borrow(),
1097 "MaybeInProgressTables: inh/fcx.typeck_results.borrow() with no typeck results"
1102 fn borrow_mut(self) -> RefMut<'a, ty::TypeckResults<'tcx>> {
1103 match self.maybe_typeck_results {
1104 Some(typeck_results) => typeck_results.borrow_mut(),
1106 "MaybeInProgressTables: inh/fcx.typeck_results.borrow_mut() with no typeck results"
1112 struct CheckItemTypesVisitor<'tcx> {
1116 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
1117 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
1118 check_item_type(self.tcx, i);
1120 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
1121 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
1124 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
1125 debug_assert!(crate_num == LOCAL_CRATE);
1126 tcx.par_body_owners(|body_owner_def_id| {
1127 tcx.ensure().typeck(body_owner_def_id);
1131 fn fatally_break_rust(sess: &Session) {
1132 let handler = sess.diagnostic();
1133 handler.span_bug_no_panic(
1135 "It looks like you're trying to break rust; would you like some ICE?",
1137 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
1138 handler.note_without_error(
1139 "we would appreciate a joke overview: \
1140 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
1142 handler.note_without_error(&format!(
1143 "rustc {} running on {}",
1144 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
1145 config::host_triple(),
1149 fn potentially_plural_count(count: usize, word: &str) -> String {
1150 format!("{} {}{}", count, word, pluralize!(count))